// ===================================================================
// Title:       Core MOF Specification 2.6
// Filename:    CIM_Core26.mof
// Version:     2.6.0
// Status:      Final
// Date:        06/04/2002
// ===================================================================
// Copyright 1998-2002 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.  
// DMTF is a not-for-profit association of industry members dedicated 
// to promoting enterprise and systems management and interoperability. 
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members, 
// provided that correct attribution is given. 
// As DMTF specifications may be revised from time to time, 
// the particular version and release date should always be noted.
//
// Implementation of certain elements of this standard or proposed 
// standard may be subject to third party patent rights, including 
// provisional patent rights (herein "patent rights"). DMTF makes 
// no representations to users of the standard as to the existence 
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or 
// claimants, nor for any incomplete or inaccurate identification or 
// disclosure of such rights, owners or claimants. DMTF shall have no 
// liability to any party, in any manner or circumstance, under any 
// legal theory whatsoever, for failure to recognize, disclose, or 
// identify any such third party patent rights, or for such party’s
// reliance on the standard or incorporation thereof in its product, 
// protocols or testing procedures. DMTF shall have no liability to 
// any party implementing such standard, whether such implementation 
// is foreseeable or not, nor to any patent owner or claimant, and shall 
// have no liability or responsibility for costs or losses incurred if 
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the 
// standard from any and all claims of infringement by a patent owner 
// for such implementations.
// 
// For information about patents held by third-parties which have 
// notified the DMTF that, in their opinion, such patent may relate to 
// or impact implementations of DMTF standards, visit 
// http://www.dmtf.org/about/policies/disclosures.php.
// ===================================================================
// Description: The Core Model defines basic management concepts 
//              such as ManagedElements, Systems, Services, Collections
//              and StatisticalInformation.  Its classes form the
//              top of the CIM object hierarchy.
//
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined 
//              by other working groups, are omitted.
// ==================================================================
//  Date 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
//  Date 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
//  Date 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
//  Date 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;
//          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 where 
//          it is inherited
//      - CR462 Update the Description for ManagedElement; Add qualifier in 
//          MemberOfCollection
//  Date 06/04/2000 - Version 2.3.2
//      - Errata, Changes in CR448b not complete / Missing delete of
//          Caption and Description properties where inherited from
//          CIM_ManagedElement for CIM_CollectionOfMSEs
//  Date 06/09/2000 - Version 2.4
//      - CR481 Change the CIM_Statistics association to reference ManagedElement,
//           not just ManagedSystemElement.
//      - CR491a Add to new values to the enumeration for 
//          ManagedSystemElement.Status and update the property's Description.
//  Date 07/14/2000 - Version 2.4
//      - CR505 - 1. Clarify the subclassing of ServiceServiceDependency
//          2. ProvidesServiceToElement needs to come before 
//             ServiceServiceDependency in MOF
//          3. Update the Description for CollectionOfMSEs to include 'bags'
//      - CR519 ERRATA CIM 2.3: correct ValueMap syntax errors in 
//          CIM_LogicalDevice.Availability 
//  Date 12/01/2000 - Version 2.5
//      - CR514j Add Deprecated qualifier
//      - CR529 CIM_LogicalDisk.StatusInfo property description refers to  
//          it as a string even though the property is a uint16
//      - CR532 Update description on PhysicalElement.OtherIdentifyingInfo 
//          to remove word "asset"
//      - CR534 Update MappingStrings Qualifiers to stay in sync with 
//          updates to the MASTER.MIF.
//      - CR536a Add EXPERIMENTAL Qualifier
//      - CR537a Add Stopped as a valid state in the enumeration for 
//          ManagedSystemElement.Status.
//      - CR544a Add DN qualifier 
//      - CR447e Add PropertyUsage qualifier
//      - CR548a Add a methods to CIM_Setting to allow a subset of the 
//          properties in the CIM_Setting instance to be verified 
//          and/or applied
//      - CR557 Change the reference for ProvidesServiceToElement.
//          Dependent to ME (was MSE) 
//      - CR564 Move AdminDomain to the Core Model, change to concrete, 
//          and update description 
//      - CR568a Corrections to CIM_CollectionOfMSEs Description 
//      - CR569 Add EmbeddedObject qualifier 
//      - CR581 Revise the description of CIM_AdminDomain.NameFormat 
//          to alter reference to Network model 
//      - CR585 Company review Changes from Compaq
//          1) Remove word "schema" from qualifier scope declarations 
//             per CIM_Spec_Errat221
//  Date 05/20/2001 - Version 2.5 Final
//      Changed format of classes to be consistent.
//  Date 05/24/2001 - Version 2.6
//      - CR583d Move the following properties and methods from
//          UnitaryComputerSystem to ComputerSystem:
//          ResetCapability, PowerManagementCapabilites, and 
//          SetPowerState.
//      - CR587 Add boolean CustomerReplaceable to the FRU class.
//      - CR588 Add new ReplaceableProductFRU association
//      - CR608 Correct the mapping strings associated with 
//          System.PrimaryOwnerName and System.Primary OwnerContact 
//          properties.
//  Date 08/23/2001 - Version 2.6
//      - CR597 Add ContainedDomain aggregation to AdminDomain.
//  Date 03/10/2002 - Version 2.6 Final
//      - CR733 Specify "IN (false)" for all "OUT only" parameters.
//      - CR746 Add the version qualifier to all classes.
//      - CR827 Clean up descriptions for AdminDomain, Realizes, and
//          SupportAccess.
//
// ==================================================================

// ==================================================================
// 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 Deprecated : string [], Scope(class, association, property, method);
Qualifier Description : string = null, Scope(any), 
    Flavor(Translatable);
Qualifier DisplayName : string = null, Scope(any),
    Flavor(Translatable);
Qualifier DN : boolean=false, 
    Scope(property, parameter), Flavor(DisableOverride); 
Qualifier EmbeddedObject : boolean = false, Scope(property);
Qualifier Expensive : boolean = false, 
    Scope(property, reference, method, class, association);
Qualifier Experimental : boolean = false, 
    Scope(any), Flavor (DisableOverride); 
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 PropertyUsage : string = "CurrentContext", Scope(property) ; 
Qualifier Provider : string = null, Scope(any);
Qualifier Read : boolean = true, Scope(property);
Qualifier Required : boolean = false, Scope(property);
Qualifier Revision : string = ".5", Scope(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.5", Scope(class, 
    association, indication), Flavor(Translatable);
Qualifier Weak : boolean = false, Scope(reference), 
      Flavor(DisableOverride, ToSubclass);
Qualifier Write : boolean = false, Scope(property);


// ==================================================================
//  UML Page 1 - ManagedElement
// ==================================================================
// ==================================================================
//    ManagedElement
// ================================================================== 
   [Abstract, Version ("2.6.0"), Description (
     "ManagedElement is an abstract class that provides a common "  
     "superclass (or top of the inheritance tree) for the "
     "non-association classes in the CIM Schema.") ]
class CIM_ManagedElement {  
      [MaxLen (64), Description (  
        "The Caption property is a short textual description (one-"    
        "line string) of the object.") ]   
   string Caption;  
      [Description (  
        "The Description property provides a textual description of "
        "the object.") ]   
   string Description;    
};
     

// ==================================================================
//    Dependency   
// ==================================================================
   [Association, Abstract, Version ("2.6.0"), Description (   
     "CIM_Dependency is a generic association used to establish "   
     "dependency relationships between ManagedElements.") ]    
class CIM_Dependency {   
      [Key, Description (   
        "Antecedent represents the independent object in this "   
        "association.") ]    
   CIM_ManagedElement REF Antecedent;   
      [Key, Description (   
        "Dependent represents the object dependent on the "   
        "Antecedent.") ]    
   CIM_ManagedElement REF Dependent;   
};   
 
                 
// ================================================================== 
//    ManagedSystemElement
// ==================================================================
   [Abstract, Version ("2.6.0"), Description (
     "CIM_ManagedSystemElement is the base class for the System "
     "Element hierarchy. Membership Criteria: Any distinguishable "
     "component of a System is a candidate for inclusion in this "
     "class. Examples: software components, such as files; and "
     "devices, such as disk drives and controllers, and physical "
     "components such as chips and cards.") ] 
class CIM_ManagedSystemElement : CIM_ManagedElement {
      [Description (
        "A datetime value indicating when the object was installed. "
        "A lack of a value does not indicate that the object is not "
        "installed."), 
       MappingStrings {"MIF.DMTF|ComponentID|001.5"} ] 
   datetime InstallDate;
      [MaxLen (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. \n" 
        "  Non-operational statuses can also be specified. These " 
        "are \"Error\", \"NonRecover\", \"Starting\", \"Stopping\", " 
        " \"Stopped\", " 
        "\"Service\", \"No Contact\" and \"Lost Comm\". \"NonRecover\" " 
        "indicates that a non-recoverable error has occurred. " 
        "\"Service\" describes an Element being configured, maintained, " 
        "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. \"No Contact\" indicates that the " 
        "current instance of the monitoring system has knowledge of " 
        "this Element but has never been able to establish " 
        "communications with it. \"Lost Comm\" indicates that the " 
        "ManagedSystemElement is known to exist and has been contacted " 
        "successfully in the past, but is currently unreachable. " 
        "\"Stopped\" indicates that the ManagedSystemElement is known " 
        "to exist, it is not operational (i.e. it is unable to " 
        "provide service to users), but it has not failed. It has " 
        "purposely been made non-operational. The Element " 
        "may have never been \"OK\", the Element may have initiated its " 
        "own stop, or a management system may have initiated the stop."), 
       ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail", 
                 "Starting", "Stopping", "Service", "Stressed", 
                 "NonRecover", "No Contact", "Lost Comm", "Stopped"} ] 
   string Status; 
};


// ==================================================================
//    Component
// ==================================================================
   [Association, Abstract, Aggregation, Version ("2.6.0"), 
    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;
};

     
// ================================================================= 
//    PhysicalElement
// ==================================================================
   [Abstract, Version ("2.6.0"), 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"
     "SystemElements (usually actual hardware items) that have a "
     "physical manifestation of some sort. A ManagedSystem"
     "Element is not necessarily a discrete component. For "
     "example, it is possible for a single Card (which is a type "
     "of PhysicalElement) to host more than one LogicalDevice. "
     "The card would be represented by a single PhysicalElement "
     "associated with multiple Devices.") ] 
class CIM_PhysicalElement : CIM_ManagedSystemElement {
      [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;
      [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;
      [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 that of " 
        "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, Version ("2.6.0"), Description (
     "CIM_LogicalElement is a base class for all the components of "
     "a System that represent abstract system components, such "
     "as Files, Processes, or LogicalDevices.") ] 
class CIM_LogicalElement : CIM_ManagedSystemElement {
};

     
// ==================================================================
//    LogicalIdentity
// ==================================================================
   [Association, Abstract, Version ("2.6.0"), 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;
};


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


// ===================================================================
//    LogicalDevice
// ===================================================================
   [Abstract, Version ("2.6.0"), 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."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"},
       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 Additional"
        "Availability 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|006",
        "MIB.IETF|HOST-RESOURCES-MIB.hrDeviceStatus", 
        "MIF.DMTF|Host Device|001.5"},
       ModelCorrespondence {"CIM_LogicalDevice.AdditionalAvailability"} ]
   uint16 Availability;
      [Description (
        "The StatusInfo property indicates 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 cannot 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|006"} ]
   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 (AdditionalAvailability 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 AdditionalAvailability 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 Additional"
        "Availability) of \"Running/Full Power\" (value=3) and a "
        "StatusInfo 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 Additional"
        "Availability) 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();        
};  

   
// ==================================================================
//    Realizes
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "CIM_Realizes is the association that defines the mapping "
     "between LogicalDevices and the PhysicalElements that "
     "implement them.") ] 
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;
};

     
// ==================================================================
//    Service
// ==================================================================  
   [Abstract, Version ("2.6.0"), Description (
     "A CIM_Service is a Logical Element that contains the "
     "information necessary to represent and manage the "
     "functionality provided by a Device and/or SoftwareFeature. "
     "A Service is a general-purpose object to configure and "
     "manage the implementation of functionality.  It is not the "
     "functionality itself.") ] 
class CIM_Service : CIM_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;
      [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;
      [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();
};

     
// ==================================================================
//    ProvidesServiceToElement
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "CIM_ProvidesServiceToElement is used to describe that "
     "ManagedElements 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 ManagedElement dependent on the Service.") ]
   CIM_ManagedElement ref Dependent;
};


// ==================================================================
//    ServiceServiceDependency
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "CIM_ServiceServiceDependency is an association between a " 
     "Service and another Service, indicating that the latter is "
     "required to be present, required to have completed, or must " 
     "be absent for the former Service to provide its "
     "functionality. For example, Boot Services may be dependent "
     "upon underlying 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_ProvidesServiceToElement {
      [Override ("Antecedent"), 
       Description ("The required Service.") ] 
   CIM_Service REF Antecedent;
      [Override ("Dependent"), Description (
        "The Service that is dependent on an underlying Service.") ] 
   CIM_Service REF Dependent;
      [Description (
        "The nature of the Service to Service dependency. This "
        "property describes that the associated Service must have "
        "completed (value=2), must be started (3) or must not be "
        "started (4) in order for the Service to function."),  
       ValueMap {"0", "1", "2", "3", "4"},
       Values {"Unknown", "Other", "Service Must Have Completed",
               "Service Must Be Started", 
               "Service Must Not Be Started"} ]
   uint16 TypeOfDependency;
      [Description(
        "this property describes that the antecedent service "
        "must be restarted after the dependent operation is "
        "complete.") ]
   boolean RestartService;
};


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

     
// ==================================================================
//    ServiceAccessPoint
// ==================================================================
   [Abstract, Version ("2.6.0"), Description (
     "CIM_ServiceAccessPoint represents the ability to utilize or "
     "invoke a Service.  Access points represent that a Service is "
     "made available to other entities for use.") ] 
class CIM_ServiceAccessPoint : CIM_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;
      [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;
};

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

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


// ==================================================================
//    ServiceAccessBySAP
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "CIM_ServiceAccessBySAP is an association that identifies the "
     "access points for a Service. For example, a printer may be "
     "accessed by Netware, MacIntosh or Windows ServiceAccess"
     "Points, potentially hosted on different Systems.") ] 
class CIM_ServiceAccessBySAP : CIM_Dependency {
      [Override ("Antecedent"),
       Description ("The Service.") ] 
   CIM_Service REF Antecedent;
      [Override ("Dependent"), Description (
        "An Access Point for a Service. Access points are dependent " 
        "in this relationship since they have no function without a "
        "corresponding Service.") ] 
   CIM_ServiceAccessPoint REF Dependent;
};

     
// ==================================================================
//    System
// ==================================================================
   [Abstract, Version ("2.6.0"), 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 (64), Description (
        "The name of the primary system owner."),
       MappingStrings {"MIF.DMTF|General Information|001.3"} ]  
   string PrimaryOwnerName;
      [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.4"} ] 
   string PrimaryOwnerContact;
      [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[];
};


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

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

// ==================================================================
//    SystemComponent
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ===================================================================
//    ComputerSystem
// ===================================================================
   [Abstract, Version ("2.6.0"), 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 cannot be resolved to a single object. "
        "Use of the heuristic is optional, but recommended. \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"
        "  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)."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", 
                 "9", "10", "11", "12", "13", "14"},
       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[];
      [Description (
        "If enabled (value = 4), the UnitaryComputerSystem can be "
        "reset via hardware (e.g. the power and reset buttons). If "
        "disabled (value = 3), hardware reset is not allowed. In "
        "addition to Enabled and Disabled, other Values for the "
        "property are also defined - \"Not Implemented\" (5), "
        "\"Other\" (1) and \"Unknown\" (2)."),
       ValueMap {"1", "2", "3", "4", "5"},
       Values {"Other", "Unknown", "Disabled",
               "Enabled", "Not Implemented"},
       MappingStrings {"MIF.DMTF|System Hardware Security|001.4"} ]
   uint16 ResetCapability;
      [Description(
        "Indicates the specific power-related capabilities of a "
        "ComputerSystem and its associated running OperatingSystem. "
        "The values, 0=\"Unknown\", 1=\"Not Supported\", and "
        "2=\"Disabled\" are self-explanatory. "
        "The value, 3=\"Enabled\" indicates that the power management "
        "features are currently enabled but the exact feature set "
        "is unknown or the information is unavailable. "
        "\"Power Saving Modes Entered Automatically\" (4) describes "
        "that a system can change its power state based on usage or "
        "other criteria. \"Power State Settable\" (5) indicates that "
        "the SetPowerState method is supported. \"Power Cycling "
        "Supported\" (6) indicates that the SetPowerState method "
        "can be invoked with the PowerState input variable set to 5 "
        "(\"Power Cycle\"). \"Timed Power On Supported\" (7) indicates "
        "that the SetPowerState method can be invoked with the Power"
        "State input variable set to 5 (\"Power Cycle\") and the Time "
        "parameter set to a specific date and time, or interval, "
        "for power-on."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"},
       Values {"Unknown", "Not Supported", "Disabled", 
               "Enabled", "Power Saving Modes Entered Automatically",
               "Power State Settable", "Power Cycling Supported",
               "Timed Power On Supported"},
       MappingStrings {"MIF.DMTF|System Power Controls|001.2"} ]
   uint16 PowerManagementCapabilities[];
      [Description(
        "SetPowerState defines the desired power state of a "
        "ComputerSystem and its running OperatingSystem, and when "
        "the system should be put into that state. The PowerState "
        "parameter is specified as one of the following integer "
        "values: 1=\"Full Power\", 2=\"Power Save - Low Power Mode\", "
        "3=\"Power Save - Standby\", 4=\"Power Save - Other\", "
        "5=\"Power Cycle\", 6=\"Power Off\", 7=\"Hibernate\" and "
        "8=\"Soft Off\". The Time parameter (for all state changes "
        "but 5, \"Power Cycle\") indicates when the power state "
        "should be set, either as a regular date-time value or as "
        "an interval value (where the interval begins when the "
        "method invocation is received). When the PowerState "
        "parameter is equal to 5, \"Power Cycle\", the Time "
        "parameter indicates when the system should power on "
        "again. Power off is immediate. SetPowerState should "
        "return 0 if successful, 1 if the specified State and "
        "Time request is not supported, and some other value if "
        "any other error occurred. In a subclass, the "
        "set of possible return codes could be specified, using a "
        "ValueMap qualifier on the method. The strings to which the "
        "ValueMap contents are 'translated' may also be specified in "
        "the subclass as a Values array qualifier.") ]
   uint32 SetPowerState(
      [IN, ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"},
           Values {"Full Power", "Power Save - Low Power Mode", 
                   "Power Save - Standby", "Power Save - Other", 
                   "Power Cycle", "Power Off", "Hibernate", 
                   "Soft Off"} ] 
      uint32 PowerState, 
      [IN] datetime Time);
};

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


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


// ==================================================================
//  UML Page 2 - FRU, Product, & Collection
// ==================================================================
// ==================================================================
//    Product
// ==================================================================
   [Version ("2.6.0"), 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 (256),
       Description ("Commonly used Product name."), 
       MappingStrings {"MIF.DMTF|ComponentID|001.2"} ] 
   string Name;
      [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 (
        "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;
      [MaxLen (64), Description (
        "Product SKU (stock keeping unit) information.") ] 
   string SKUNumber;
      [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, Version ("2.6.0"), 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, Version ("2.6.0"), 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, Version ("2.6.0"), 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."),  
       ValueMap {"0", "1", "2", "3"},
       Values {"Unknown", "Other", "Product Must Be Installed", 
               "Product Must Not Be Installed"} ]
   uint16 TypeOfDependency; 
};

     
// ==================================================================
//    SupportAccess
// ==================================================================
   [Version ("2.6.0"), Description (
     "The CIM_SupportAccess association defines how to obtain "
     "assistance for a Product.") ] 
class CIM_SupportAccess : CIM_ManagedElement {
      [Override ("Description"), Description (
        "A textual description of the type of Support provided."),
       MappingStrings {"MIF.DMTF|Support|001.3"} ] 
   string Description;
      [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;
      [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;
      [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;
};

     
// ==================================================================
//    ProductSupport
// ==================================================================
   [Association, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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;
      [Key, MaxLen (256),
       Description ("The name of the FRU's supplier."), 
       MappingStrings {"MIF.DMTF|FRU|002.4"} ] 
   string Vendor;
      [Description ("FRU name."), MaxLen (256) ] 
   string Name;
      [MaxLen (64), Description ("The FRU's revision level."),
       MappingStrings {"MIF.DMTF|FRU|002.8"} ] 
   string RevisionLevel;
      [Description ("Indicates whether the FRU is "
        "customer replaceable.") ]
   boolean CustomerReplaceable;
};
    
     
// ==================================================================
//    ProductFRU
// ==================================================================
   [Association, Version ("2.6.0"), 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;
};

     
// ==================================================================
//    ReplaceableProductFRU
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "ReplaceableProductFRU is an association between Product and "
     "FRU that shows what Product components may be 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_ReplaceableProductFRU {
      [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, Version ("2.6.0"), 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, Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ==================================================================
//    Collection 
// ================================================================== 
   [Abstract, Version ("2.6.0"), 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 {   
};


// ==================================================================
//    MemberOfCollection    
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), 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;   
};   


// ===================================================================
//    CollectionOfMSEs
// ===================================================================
   [Abstract, Version ("2.6.0"), Description (
     "  The CollectionOfMSEs object allows the grouping of Managed"
     "SystemElements for various identification purposes and to "
     "reduce the complexity 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 subclassed from LogicalElement). \n"
     "  Collections typically aggregate 'like'objects, but are " 
     "not required to do so.  They simply identify 'bags' and "
     "may represent an optimization. This is especially true "
     "with respect to their association to Settings and "
     "Configurations. Without Collections, one is forced to "
     "define individual ElementSetting andElementConfiguration "
     "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 ifthe 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;
};


// ==================================================================
//    CollectedCollections
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), 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;
};

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


// ==================================================================
//  UML Page 3 - Statistics
// ==================================================================
// ==================================================================
//    StatisticalInformation
// ================================================================== 
   [Abstract, Version ("2.6.0"), 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, Version ("2.6.0"), Description ( 
     "CIM_Statistics is an association that relates Managed" 
     "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 ManagedElement for which statistical or metric " 
        "data is defined.") ] 
   CIM_ManagedElement REF Element;
};


// ==================================================================
//    RelatedStatistics
// ================================================================== 
   [Association, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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
// ==================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ==================================================================
//  UML Page 4 - Settings
// ==================================================================
// ===================================================================
//    Setting
// ===================================================================
   [Abstract, Version ("2.6.0"), 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 cannot 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 cannot 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,
      [IN (false), 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 cannot 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, 
      [IN (false), OUT] string CanNotApply[]);
      [Description ( 
        "The VerifyOKToApplyIncrementalChangeToMSE method " 
        "is used to verify that a subset of the properties in " 
        "this Setting can be 'applied' to the referenced Managed" 
        "SystemElement, at the given time or time interval. This " 
        "method takes four 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), MustBeCompletedBy (which indicates the " 
        "required completion time for the method), and a " 
        "PropertiesToApply array (which contains a list of the " 
        "property names whose values will be verified.) " 
        "If the array is null, empty or contains the string \"ALL\" " 
        "as a property name, then all Settings properties shall be " 
        "verified.  If it is set to \"NONE\", then no Settings " 
        "properties will be verified. 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 cannot 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 VerifyOKToApplyIncrementalChangeToMSE( 
      [IN] CIM_ManagedSystemElement ref MSE, 
      [IN] datetime TimeToApply, 
      [IN] datetime MustBeCompletedBy, 
      [IN] string PropertiesToApply[]); 
      [Description ( 
        "  The ApplyIncrementalChangeToMSE method performs the " 
        "actual application of a subset of the properties in " 
        "the Setting to the referenced ManagedSystemElement. It " 
        "takes four 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), MustBeCompletedBy " 
        "(which indicates the required completion time for the " 
        "method), and a PropertiesToApply array (which contains a "
        "list of the property names whose values will be applied.) If a " 
        "property is not in this list, it will be ignored by the Apply. " 
        "If the array is null, empty or contains the string \"ALL\" " 
        "as a property name, then all Settings properties shall be " 
        "applied.  If it is set to \"NONE\", then no Settings " 
        "properties will be applied. \n" 
        "  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 ApplyIncrementalChangeToMSE( 
      [IN] CIM_ManagedSystemElement ref MSE, 
      [IN] datetime TimeToApply, 
      [IN] datetime MustBeCompletedBy, 
      [IN] string PropertiesToApply[]); 
      [Description ( 
        "  The VerifyOKToApplyIncrementalChangeToCollection method " 
        "is used to verify that a subset of the properties in " 
        "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 " 
        "VerifyOKToApplyIncrementalChangeToMSE 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), MustBeCompletedBy (which indicates the " 
        "required completion time for the method), and a " 
        "PropertiesToApply array (which contains a list of the " 
        "property names whose values will be verified. " 
        "If they array is null or empty or constains the string \"all\" " 
        "as a property name then all Settings properties shall be " 
        "verified.  If it is set to \"none\" then no Settings properties " 
        "will be verified). 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 cannot 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 VerifyOKToApplyIncrementalChangeToCollection ( 
      [IN] CIM_CollectionOfMSEs ref Collection, 
      [IN] datetime TimeToApply, 
      [IN] datetime MustBeCompletedBy, 
      [IN] string PropertiesToApply[], 
      [IN (false), OUT] string CanNotApply[]); 
      [Description ( 
        "  The ApplyIncrementalChangeToCollection method performs " 
        "the application of a subset of the properties in this " 
        "Setting to the referenced Collection of ManagedSystem" 
        "Elements. The net effect is to execute the " 
        "ApplyIncrementalChangeToMSE " 
        "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), and a PropertiesToApply array (which contains a list " 
        "of the property names whose values will be applied.) If a " 
        "property is not in this list, it will be ignored by the Apply. " 
        "If the array is null or empty or contains the string \"ALL\" " 
        "as a property name, then all Settings properties shall be " 
        "applied. If it is set to \"NONE\", then no Settings properties " 
        "will be applied. \n"
        "  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 time, 3 if the Setting cannot 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 ApplyIncrementalChangeToCollection( 
      [IN] CIM_CollectionOfMSEs ref Collection, 
      [IN] datetime TimeToApply, 
      [IN] boolean ContinueOnError, 
      [IN] datetime MustBeCompletedBy, 
      [IN] string PropertiesToApply[], 
      [IN (false), OUT] string CanNotApply[]); 
};


// ===================================================================
//    ElementSetting
// ===================================================================
   [Association, Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ================================================================== 
//    MethodParameters 
// ================================================================== 
    [Abstract, Version ("2.6.0"), Description (
      "  CIM_MethodParameters represents a set of values to be used "
      "as the parameters of a method. These parameters may be passed "
      "to the method, diretly used by the method in its invocation, "
      "or accessed by the method when it is called. The properties "
      "of a concrete subclass of MethodParameters are mapped to the "
      "parameters of a method by the method itself or by the method "
      "caller. This is an implementation detail independent of the "
      "definition of the class. For ease of use, property names "
      "should match parameter names. \n"
      "  Property values should be set before the method is invoked. " 
      "The ModelCorrespondence qualifier can be used to indicate " 
      "if the property value should come from another class's property. " 
      "The instances that the property values should be gleaned from " 
      "should be associated with MethodParameters using the Parameter"
      "ValueSources association. If the property is declared as an "
      "array, then the same property value (identified by the Model"
      "Correspondence) will be retrieved from all appropriate "
      "ParameterValueSources instances and stored in the array. If "
      "the property is declared as an array and the Model"
      "Correspondence is to an array property, then only one instance "
      "of the array will be copied from one ParameterValueSource. " 
      "If the property is not declared as an array and there are " 
      "multiple instances of the class and property associated with " 
      "it through ModelCorrespondence where the values are not all "
      "the same, then an error will occur and the property's value "
      "will not be set. Several MethodParameters instances can be "
      "associated with any ManagedElement's methods. This allows the " 
      "maintenance of 'canned' method invocation and reduces the " 
      "overhead of recreating all method parameters for every method " 
      "invocation.") ] 
class CIM_MethodParameters : CIM_ManagedElement { 
      [Maxlen (256) , Description ( 
        "The identifier by which the MethodParameters object is known.") ] 
    string MethodParametersId ; 
      [Description ( 
        "The resetValues method updates the values of the properties of " 
        "MethodParameters which have ModelCorrespondence to the " 
        "SourceME ManagedElement. This allows the association of " 
        "several source candidates with the MethodParameters with " 
        "one being chosen as the source for this set of values. " 
        "If resetValues is invoked and sourceME is null, then all " 
        "associated MEs in ParameterValueSources will be used " 
        "to set the values of the MethodParameters properties.") ]
    uint32 ResetValues([IN] CIM_ManagedElement ref SourceME); 
}; 


// =================================================================== 
//    ParameterValueSources 
// =================================================================== 
    [Association, Version ("2.6.0"), Description ( 
      "ParameterValueSources represents the association between " 
      "a MethodParameters instance and the ManagedElement instances " 
      "which contain properties to be used to create values " 
      "for the MethodParameters properties.") ] 
class CIM_ParameterValueSources {        
      [Key, Description ( 
        "The MethodParameters instance whose property values "
        "are to be set.") ] 
    CIM_MethodParameters ref Parameters; 
      [Key, Description (
        "The ManagedElement which contains properties to be used " 
         "to populate the values of the properties of the "
         "MethodParameters instance.") ] 
    CIM_ManagedElement ref ValueSource; 
}; 


// =================================================================== 
//    ParametersForMethod 
// =================================================================== 
    [Association, Version ("2.6.0"), Description ( 
      "ParametersForMethod represents the association between "
      "MethodParameters class(es) and a ManagedElement which has a "
      "method that may use the MethodParameters during its "
      "invocation. This association is optional, as the Method"
      "Parameters instance may be passed as a parameter to a method " 
      "or used to create a method signature before the method is "
      "invoked. This association is useful for finding all the valid "
      "MethodParameters instances for a particular method. It may "
      "be particularly useful for user-oriented interfaces and "
      "automated or policy driven method invocations.") ] 
class CIM_ParametersForMethod {       
      [Key, Description (
        "The MethodParameters instance which may be used by the "
        "ParametersForMethod's method invocation.") ]
    CIM_MethodParameters ref Parameters;
      [Key, Description ("The ManagedElement which has "
        "a method that may use this instance of MethodParameters.") ]
    CIM_ManagedElement ref TheMethod;
      [Key, MaxLen(64),Description ("The name of the method that "
        "may use the referenced instance of MethodParameters during "
        "its invocation.") ]
    string MethodName;
}; 


// ==================================================================
//     CIM_SystemSetting
// ==================================================================
    [Abstract, Version ("2.6.0"), Description (
      "CIM_SystemSetting represents the general concept of a "
      "CIM_Setting which is scoped by/weak to a System.") ]
class CIM_SystemSetting : CIM_Setting {
      [Propagated ("CIM_System.CreationClassName"), Key, 
       MaxLen (256), Description (
        "The scoping System's CreationClassName.") ] 
    string SystemCreationClassName;
      [Propagated ("CIM_System.Name"), Key, MaxLen (256),
       Description ("The scoping System's Name.") ] 
    string SystemName;
      [Key, MaxLen (256), Description (
        "CreationClassName indicates the name of the class or the "
        "subclass used in the creation of an instance. When used "
        "with the other key properties of this class, this property "
        "allows all instances of this class and its subclasses to "
        "be uniquely identified.") ]
    string CreationClassName;
      [Override ("SettingID"), Key, MaxLen (256) ]
    string SettingID;
};


// ==================================================================
//     CIM_SettingForSystem
// ==================================================================
    [Association, Version ("2.6.0"), Description (
      "CIM_SettingForSystem defines a Setting in the context "
      "of the System on which it resides.") ]
class CIM_SettingForSystem : CIM_Dependency {
      [Override ("Antecedent"), Max (1), Min (1),
       Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
      [Override ("Dependent"), Weak,
       Description ("The Setting defined for the System.") ] 
    CIM_SystemSetting REF Dependent;
};


// ==================================================================
//  UML Page 5 - Configuration
// ==================================================================
// ===================================================================
//    Configuration
// ===================================================================
   [Version ("2.6.0"), 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, Version ("2.6.0"), 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, Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ===================================================================
//    DependencyContext
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), 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;
};

     
// ===================================================================
//    SettingContext
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), 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, Version ("2.6.0"), 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;
};


// ==================================================================
//     CIM_SystemConfiguration
// ==================================================================
    [Version ("2.6.0"), Description (
      "CIM_SystemConfiguration represents the general concept "
      "of a CIM_Configuration which is scoped by/weak to a "
      "System. This class is a peer of CIM_Configuration since "
      "the key structure of Configuration is currently "
      "defined and cannot be modified with additional "
      "properties.") ]
class CIM_SystemConfiguration : CIM_ManagedElement {
      [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), Description (
        "The label by which the Configuration object is known.") ]
    string Name;
};
 

// ==================================================================
//     CIM_ConfigurationForSystem
// ==================================================================
    [Association, Version ("2.6.0"), Description (
      "CIM_ConfigurationForSystem defines a Configuration "
      "in the context of the System on which it resides.") ]
class CIM_ConfigurationForSystem : CIM_Dependency {
      [Override ("Antecedent"), Max (1), Min (1),
       Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
      [Override ("Dependent"), Weak,
       Description ("The Configuration defined for the System.") ] 
    CIM_SystemConfiguration REF Dependent;
};


// ==================================================================
//     CIM_SystemSettingContext
// ==================================================================
    [Association, Aggregation, Version ("2.6.0"), Description (
      "This relationship associates System-specific Configuration "
      "objects with System-specific Setting objects, similar to the "
      "SettingContext association.") ]
class CIM_SystemSettingContext {
      [Aggregate, Key, Description (
        "The Configuration object that aggregates the Setting.") ]
   CIM_SystemConfiguration REF Context;
      [Key, Description ("An aggregated Setting.") ]
   CIM_SystemSetting REF Setting;
};


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