#pragma namespace ("/root/ibm")
#pragma locale ("en_US")


// ==================================================================
// Qualifiers
// ==================================================================
Qualifier Abstract : boolean = false, 
    Scope(class, association, indication), 
    Flavor(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),
    Flavor(DisableOverride);

Qualifier Association : boolean = false, 
    Scope(association), 
    Flavor(DisableOverride);

Qualifier BitMap : string[], 
    Scope(property, method, parameter);

Qualifier BitValues : string[], 
    Scope(property, method, parameter), 
    Flavor(Translatable);

Qualifier Composition : boolean = false, 
    Scope(association),
    Flavor(DisableOverride);

Qualifier Counter : boolean = false, 
    Scope(property, method, parameter);

Qualifier Delete : boolean = false, 
    Scope(association, reference);

Qualifier Deprecated : string [], 
    Scope(any),
    Flavor(Restricted);

Qualifier Description : string = null, 
    Scope(any), 
    Flavor(Translatable);

Qualifier DisplayName : string = null, 
    Scope(any),
    Flavor(Translatable);

Qualifier DN : boolean=false, 
    Scope(property, method, parameter), 
    Flavor(DisableOverride); 

Qualifier EmbeddedObject : boolean = false, 
    Scope(property, method, parameter),
    Flavor(DisableOverride); 

Qualifier Exception: boolean = false,
    Scope(class, indication), 
    Flavor(disableoverride, tosubclass); 

Qualifier Expensive : boolean = false, 
    Scope(any);

Qualifier Experimental : boolean = false, 
    Scope(any), 
    Flavor(Restricted); 

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(any);
    
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 MinLen : uint32 = 0,
    Scope(property, method, parameter);
    
Qualifier MinValue : sint64 = null, 
    Scope(property, method, parameter);

Qualifier ModelCorrespondence : string[], 
    Scope(any);

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, method, parameter), 
    Flavor(DisableOverride);

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, reference, parameter),
    Flavor(DisableOverride);

//  The Revision qualifer has been deprecated. For the replacement, 
//  see the usage rule for the version qualifer in the CIM 
//  Specification. 
Qualifier Revision : string = null, 
    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, association, indication);

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 = null, 
    Scope(class, association, indication), 
    Flavor(Restricted, Translatable);

Qualifier Weak : boolean = false, 
    Scope(reference), 
    Flavor(DisableOverride, ToSubclass);

Qualifier Write : boolean = false, 
    Scope(property);


// IBM vendor specific qualifiers
// 11/26/2002	a.wolf-reber@de.ibm.com

Qualifier ExecuteRole : string = "Administrator", 
    Scope(method);

Qualifier AccessRole : string = "Monitor",
	scope(class);

Qualifier CreateRole : string = "CIMOM",
	scope(class);

Qualifier EditRole : string = "CIMOM",
	scope(class);

Qualifier DeleteRole : string = "CIMOM",
	scope(class);

Qualifier ReadRole : string = "Monitor", 
    Scope(property);

Qualifier WriteRole : string = "CIMOM", 
    Scope(property);

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


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

      [Description (
          "The Caption property is a short textual description (one- "
          "line string) of the object."), 
       MaxLen ( 64 )]
   string Caption;

      [Description (
          "The Description property provides a textual description of "
          "the object.")]
   string Description;

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


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


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


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

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

      [Description (
          "The date/time when the element's EnabledState last "
          "changed.  If the state of the element has not changed and "
          "this property is populated, then it MUST be set to a 0 "
          "interval value.  If a state change was requested, but "
          "rejected or not yet processed, the property MUST NOT be "
          "updated.")]
   datetime TimeOfLastStateChange;
    
      [Description (
          "Requests that the element's state be changed to the value "
          "specified in the RequestedState parameter.  When the "
          "requested state change takes place, the element's "
          "EnabledState and RequestedState will be the same.  Invoking "
          "the RequestStateChange method multiple times could result "
          "in earlier requests being overwritten/lost.  \n"
          "If 0 is returned, then the task completed successfully and "
          "the use of ConcreteJob was not required.  If 4096 (0x1000) "
          "is returned, then the task will take some time to complete, "
          "ConcreteJob will be created, and its reference returned in "
          "the output parameter Job.  Any other return code indicates "
          "an error condition."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
          "4097", "4098", "4099", "4100..32767", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported",
          "Unknown/Unspecified Error",
          "Can NOT complete within Timeout Period", "Failed",
          "Invalid Parameter", "In Use", "DMTF Reserved",
          "Method Parameters Checked - Job Started",
          "Invalid State Transition",
          "Use of Timeout Parameter Not Supported", "Busy",
          "Method Reserved", "Vendor Specific" }, 
       ModelCorrespondence { "CIM_EnabledLogicalElement.RequestedState" 
          }]
    uint32 RequestStateChange(
         [IN, Description (
             "The state requested for the element.  This information "
             "will be placed into the instance's RequestedState "
             "property if the RequestStateChange method's return code "
             "is 0, 3, or 4096 (0x1000) - 'Completed with No Error', "
             "'Timeout', or 'Job Started' respectively.  Refer to the "
             "description of the EnabledState and RequestedState "
             "properties for the detailed meanings of the "
             "RequestedState values."), 
          ValueMap { "2", "3", "4", "6", "7", "8", "9", "10", "11",
             "..", "32768..65535" }, 
          Values { "Enabled", "Disabled", "Shut Down", "Offline",
             "Test", "Defer", "Quiesce", "Reboot", "Reset",
             "DMTF Reserved", "Vendor Reserved" }, 
          ModelCorrespondence { 
             "CIM_EnabledLogicalElement.RequestedState" }]
      uint16 RequestedState, 
         [IN ( false ), OUT, Description (
             "Reference to the job (may be null if task completed).")]
      CIM_ConcreteJob REF Job, 
         [IN, Description (
             "A timeout period that specifies the maximum amount of "
             "time that the client expects the transition to the new "
             "state to take.  The interval format MUST be used to "
             "specify the TimeoutPeriod.  A value of 0 or a null "
             "parameter indicates that the client has no time "
             "requirements for the transition.  \n"
             "If this property does not contain 0 or null and the "
             "implementation doesn't support this parameter.  A return "
             "code of 'Use Of Timeout Parameter Not Supported' MUST be "
             "returned.")]
      datetime TimeoutPeriod);
};


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

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


// ===================================================================
// WBEMService
// ===================================================================
   [Abstract, Version ( "2.6.0" ), Description (
       "An abstract class for WBEM services such as the ObjectManager "
       "(CIM Server), Providers, protocol adapters, or other pluggable "
       "components.  A type of CIM_Service that provides associated "
       "capabilities and details about the communication capabilities, "
       "namespaces, etc.  for a specific WBEMService.")]
class CIM_WBEMService : CIM_Service { 
};


// ===================================================================
// ObjectManager
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A type of CIM_Service that defines the capabilities of the CIM "
       "Server in which this ObjectManager class resides.  Details "
       "related to communicating with the ObjectManager, and the "
       "Manager's basic capabilities, are stored in instances of the "
       "associated CommunicationMechanism class available through the "
       "CommMechanismForManager association.  It is assumed that Basic "
       "Read operations must be supported by all ObjectManager's in "
       "order to retrieve any additional detail.")]
class CIM_ObjectManager : CIM_WBEMService { 

      [Write, Description (
          "The GatherStatisticalData property is used to control the "
          "gathering of statistical data made accessible through the "
          "CIM_CIMOMStatisticalData objects.  If set to true, the data "
          "is gathered and can be accessed.  If false, the "
          "CIM_CIMOMStatisticalData instance MAY exist but MUST show "
          "zero values for the counter properties.")]
    boolean GatherStatisticalData = true;

      [Override ( "Name" ), Description (
          "The Name property is used to uniquely identify a CIM "
          "Server.  The CIM Server MUST ensure that this value is "
          "globally unique.  In order to ensure uniqueness, this value "
          "SHOULD be constructed in the following manner.  <Vendor "
          "ID>:<Unique ID> \n"
          "<Vendor ID> MUST include a copyrighted, trademarked or "
          "otherwise unique name that is owned by the business entity "
          "or a registered ID that is assigned to the business entity "
          "that is defining the Name.  (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) The "
          "purpose of <Vendor ID> is to ensure that <ID> is truly "
          "unique across multiple vendor implementations.  If such a "
          "name is not used, the defining entity MUST assure that the "
          "<ID> portion of the Instance ID is unique when compared "
          "with other instance providers.  For DMTF defined instances, "
          "the <Vendor ID> is 'CIM'.  \n"
          "<Unique ID> MUST include a vendor specified unique "
          "identifier.  \n"
          "Note: Name is semantically the same as InstanceID.  In the "
          "next major version of the CIM Schema, Name will be renamed "
          "to InstanceID and become the only key of this class.")] 
    string Name; 

      [Override ( "ElementName" ), Description (
          "The ElmentName property is used as a name of the CIM Server "
          "for human interfaces.  For example, \"ACME CIM Server\").  "
          "This property is required to support the SLP discovery "
          "mechanism.  In the next major release this property MAY "
          "include the required qualifier.")] 
    string ElementName; 

      [Override ( "Description" ), Description (
          "The description property is used as a description of the "
          "CIM Server for human interfaces.  For example, \" ACME CIM "
          "Server version 2.2\").  This property is required to "
          "support the SLP discovery mechanism.  In the next major "
          "release this property MAY include the required qualifier.")]  
    string Description; 
};


// ===================================================================
// Provider
// ===================================================================
[Version ("2.7.1000"), Experimental, Description (
    "A CIM Provider is a type of CIM_WBEMService that "
    "instruments one or more aspects of the CIM Schema.  A "
    "CIM_Provider operates at the request of the "
    "CIM_ObjectManager to perform operations on CIM objects. " 
    "The properties CreationClasName, SystemCreationClassName and " 
    "SystemName can be set to empty strings. In this case, " 
    "the CIM Object Manager must interpret the properties with the " 
    "local system information.") ] 
class CIM_Provider : CIM_WBEMService { 
 
    [Override ("Name"), Description (
        "A human-readable name that uniquely "
        "identifies the provider within a system.") ]
    string Name; 
 
    [Required, Description (
        "An implementation specific string that identifies the "
        "handle to the provider.") ]
    string Handle;
};


// ===================================================================
// SecurityService
// ===================================================================
   [Abstract, Version ( "2.6.0"), Description (
       "A service providing security functionaity.") ]
class CIM_SecurityService : CIM_Service {
};


// ===================================================================
// AccountManagementService
// ===================================================================
   [Version ( "2.6.0"), Description (
       "CIM_AccountManagementService creates, manages, and if "
       "necessary destroys Accounts on behalf of other "
       "SecuritySerices.") ]
class CIM_AccountManagementService : CIM_SecurityService {
};


// ===================================================================
// AuthorizationService
// ===================================================================
   [Version ( "2.8.0"), Description (
       "CIM_AuthorizationService determines whether an Identity, "
       "established by an AuthorizationService, is permitted access to "
       "a resource or set of resources.") ]
class CIM_AuthorizationService : CIM_SecurityService {
};


// ===================================================================
// Privilege
// ===================================================================
   [Version ( "2.8.0"), Description (
       "Privilege is the base class for all types of activities which "
       "are granted or denied by a Role or an Identity.  Whether an "
       "individual Privilege is granted or denied is defined using the "
       "PrivilegeGranted boolean.  Any Privileges not specifically "
       "granted are assumed to be denied.  An explicit deny (Privilege "
       "Granted = FALSE) takes precedence over any granted "
       "Privileges.  \n"
       "\n"
       "The association of subjects (Roles and Identities) to Privileges "
       "is accomplished using policy or explicitly via the associations "
       "on a subclass. The entities that are protected (targets) can be "
       "similarly defined. \n"
       "\n"
       "Note that Privileges may be inherited through hierarchical "
       "Roles, or may overlap.  For example, a Privilege denying any "
       "instance Writes in a particular CIM Server Namespace would "
       "overlap with a Privilege defining specific access rights at an "
       "instance level within that Namespace.  In this example, the "
       "AuthorizedSubjects are either Identities or Roles, and the "
       "AuthorizedTargets are a Namespace in the former case, and a "
       "particular instance in the latter.") ]
class CIM_Privilege : CIM_ManagedElement {

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority. (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "For DMTF defined instances, the 'preferred' algorithm "
          "MUST be used with the <OrgID> set to 'CIM'.") ]       
   string InstanceID;

   [Description (
      "Boolean indicating whether the Privilege is granted (TRUE) or "
      "denied (FALSE). The default is to grant permission.") ]
    boolean PrivilegeGranted = TRUE;

      [Description (
          "An enumeration indicating the activities that are granted "
          "or denied.  These activities apply to all entities "
          "specified in the ActivityQualifiers array.  The values in "
          "the enumeration are straightforward except for one, "
          "4=\"Detect\".  This value indicates that the existence or "
          "presence of an entity may be determined, but not "
          "necessarily specific data (which requires the Read "
          "privilege to be true).  This activity is exemplified by "
          "'hidden files'- if you list the contents of a directory, "
          "you will not see hidden files.  However, if you know a "
          "specific file name, or know how to expose hidden files, "
          "then they can be 'detected'.  Another example is the "
          "ability to define search privileges in directory "
          "implementations."), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7", "..15999",
          "16000.."}, 
       Values { "Other", "Create", "Delete", "Detect", "Read", "Write",
          "Execute", "DMTF Reserved", "Vendor Reserved"}, 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { "CIM_Privilege.ActivityQualifiers"} ]
   uint16 Activities[];

      [Description (
          "The ActivityQualifiers property is an array of string "
          "values used to further qualify and specify the privileges "
          "granted or denied.  For example, it is used to specify a "
          "set of files for which 'Read'/'Write' access is permitted "
          "or denied.  Or, it defines a class' methods that may be "
          "'Executed'.  Details on the semantics of the individual "
          "entries in ActivityQualifiers are provided by corresponding "
          "entries in the QualifierFormats array."), 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { "CIM_Privilege.Activities",
          "CIM_Privilege.QualifierFormats"} ]
   string ActivityQualifiers[];

      [Description (
          "Defines the semantics of corresponding entries in the "
          "ActivityQualifiers array.  An example of each of these "
          "'formats' and their use follows: \n"
          "- 2=Class Name.  Example: If the authorization target is a "
          "CIM Service or a Namespace, then the ActivityQualifiers "
          "entries can define a list of classes that the authorized "
          "subject is able to create or delete.  \n"
          "- 3=<Class.>Property.  Example: If the authorization target "
          "is a CIM Service, Namespace or Collection of instances, then "
          "the ActivityQualifiers entries can define the class "
          "properties that may or may not be accessed.  In this case, "
          "the class names are specified with the property names to "
          "avoid ambiguity - since a CIM Service, Namespace or "
          "Collection could manage multiple classes.  On the other "
          "hand, if the authorization target is an individual instance, "
          "then there is no possible ambiguity and the class name may "
          "be omitted.  To specify ALL properties, the wildcard string "
          "\"*\" should be used.  \n"
          "- 4=<Class.>Method.  This example is very similar to the "
          "Property one, above.  And, as above, the string \"*\" may "
          "be specified to select ALL methods.  \n"
          "- 5=Object Reference.  Example: If the authorization target "
          "is a CIM Service or Namespace, then the ActivityQualifiers "
          "entries can define a list of object references (as strings) "
          "that the authorized subject can access.  \n"
          "- 6=Namespace.  Example: If the authorization target is a "
          "CIM Service, then the ActivityQualifiers entries can define a "
          "list of Namespaces that the authorized subject is able to "
          "access.  \n"
          "- 7=URL.  Example: An authorization target may not be "
          "defined, but a Privilege could be used to deny access to "
          "specific URLs by individual Identities or for specific Roles, "
          "such as the 'under 17' Role. \n"
          "- 8=Directory/File Name.  Example: If the authorization target "
          "is a FileSystem, then the ActivityQualifiers entries can "
          "define a list of directories and files whose access is "
          "protected.  \n"
          "- 9=Command Line Instruction.  Example: If the authorization "
          "target is a ComputerSystem or Service, then the "
          "ActivityQualifiers entries can define a list of command "
          "line instructions that may or may not be 'Executed' by the "
          "authorized subjects."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "..15999",
          "16000.."}, 
       Values { "Class Name", "<Class.>Property", "<Class.>Method",
          "Object Reference", "Namespace", "URL",
          "Directory/File Name", "Command Line Instruction",
          "DMTF Reserved", "Vendor Reserved"}, 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { "CIM_Privilege.ActivityQualifiers"} ]
   uint16 QualifierFormats[];
};


// ==================================================================
// AuthorizedPrivilege
// ==================================================================
   [Version ("2.8.0"), Description (
       "Privilege is the base class for all types of activities "
       "which are granted or denied to a Role or an Identity. "
       "AuthorizedPrivilege is a subclass defining static renderings "
       "of authorization policy rules. The association of Roles and "
       "Identities to AuthorizedPrivilege is accomplished using the "
       "AuthorizedSubject relationship. The entities that are "
       "protected are defined using the AuthorizedTarget "
       "relationship. \n"
       "\n"
       "Note that this class and its AuthorizedSubject/Target "
       "associations provide a short-hand, static mechanism to represent "
       "authorization policies.") ]
class CIM_AuthorizedPrivilege : CIM_Privilege {
};


// ===================================================================
// PrivilegeManagementService
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The PrivilegeManagementService is responsible for creating, "
       "deleting, and associating AuthorizedPrivilege instances. "
       "References to 'subject' and 'target' define the entities that "
       "are associated with an AuthorizedPrivilege instance via the "
       "relationships, AuthorizedSubject and AuthorizedTarget, "
       "respectively. When created, an AuthorizedPrivilege instance is "
       "related to this (PrivilegeManagement)Service via the "
       "association, ConcreteDependency.")]
class CIM_PrivilegeManagementService: CIM_AuthorizationService {

      [Description (
          "When this method is called, a provider updates the specified "
          "Subject's rights to the Target according to the parameters "
          "of this call. The rights are modeled via an AuthorizedPrivilege "
          "instance. If an AuthorizedPrivilege instance is created "
          "as a result of this call, it MUST be linked to the Subject and "
          "Target via the AuthorizedSubject and AuthorizedTarget "
          "associations, respectively. When created, the "
          "AuthorizedPrivilege instance is associated to this "
          "PrivilegeManagementService via ConcreteDependency. If the "
          "execution of this call results in no rights between the Subject "
          "and Target, then they MUST NOT be linked to a particular "
          "AuthorizedPrivilege instance via AuthorizedSubject and "
          "AuthorizedTarget respectively. \n"
          "\n"
          "Note that regardless of whether specified via parameter, or "
          "template, the Activities, ActivityQualifiers and "
          "QualifierFormats, are mutually indexed. Also note that "
          "Subject and Target references MUST be supplied. \n "
          "\n"
          "The successful completion of the method SHALL create any "
          "necessary AuthorizedSubject, AuthorizedTarget, "
          "AuthorizedPrivilege, HostedDependency, and ConcreteDependency "
          "instances."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..15999", "16000",
          "16001", "16002", "16003", "16004", "16005..31999",
          "32000..65535"}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Unsupported Subject", "Unsupported Privilege",
          "Unsupported Target", "Authorization Error",
          "NULL not supported", "Method Reserved", "Vendor Specific"} ]
   uint32 AssignAccess (
       
       [Required, IN, Description (
       "The Subject parameter is a reference to a ManagedElement instance. "
       "This parameter MUST be supplied.") ]
       CIM_ManagedElement REF Subject,
       
       [IN, Description (
       "MUST be NULL unless Privilege is NULL on input. "
       "The PrivilegeGranted flag indicates whether the rights defined "
       "by the parameters in this call should be granted or denied to the "
       "named Subject/Target pair." ), 
       ModelCorrespondence{"CIM_AuthorizedPrivilege.PrivilegeGranted", 
       "CIM_PrivilegeManagementService.AssignAccess.Privilege"} ]
       boolean PrivilegeGranted,
       
       [IN, Description (
       "MUST be NULL unless the Privilege is NULL on input. This "
       "parameter specifies the activities to be granted or denied." ),
       ArrayType ("Indexed"),
       ValueMap {"1", "2", "3", "4", "5", "6", "7", "..",
       "16000..65535"},
       Values {"Other", "Create", "Delete", "Detect", "Read",
       "Write", "Execute", "DMTF Reserved", "Vendor Reserved"},
       ModelCorrespondence{"CIM_AuthorizedPrivilege.Activities",
       "CIM_PrivilegeManagementService.AssignAccess.Privilege"} ]
       uint16 Activities[],
       
       [IN, Description (
       "MUST be NULL unless Privilege is NULL on input. This "
       "parameter defines the activity qualifiers for the Activities "
       "to be granted or denied." ),
       ArrayType ("Indexed"),
       ModelCorrespondence{"CIM_AuthorizedPrivilege.ActivityQualifers", 
       "CIM_PrivilegeManagementService.AssignAccess.Privilege"} ]
       string ActivityQualifiers[],
       
       [IN, Description (
       "MUST be NULL unless Privilege is NULL on input. This "
       "parameter defines the qualifier formats for the corresponding "
       "ActivityQualifiers." ),
       ArrayType ("Indexed"),
       ValueMap {"2", "3", "4", "5", "6", "7", "8", "9",
       "10..15999", "16000..65535"},
       Values {"Class Name", "<Class.>Property",
       "<Class.>Method", "Object Reference", "Namespace",
       "URL", "Directory/File Name",
       "Command Line Instruction", "DMTF Reserved",
       "Vendor Reserved"},
       ModelCorrespondence{"CIM_AuthorizedPrivilege.QualifierFormats", 
       "CIM_PrivilegeManagementService.AssignAccess.Privilege"} ]
       uint16 QualifierFormats[],
       
       [Required, IN, Description (
       "The Target parameter is a reference to an instance of "
       "ManagedElement. This parameter MUST be supplied.") ]
       CIM_ManagedElement REF Target,
       
       [IN, OUT, Description (
       "On input, this reference MUST be either NULL or refer to an "
       "instance of AuthorizedPrivilege that is used as a template. The "
       "rights granted by corresponding entries in the Activities, "
       "ActivityQualifiers and QualifierFormats array properties are "
       "applied incrementally and do not affect unnamed rights. If "
       "the property, PrivilegeGranted, is false, then the named rights "
       "are removed. If PrivilegeGranted is True, then the named rights "
       "are added. (Note that the RemoveAccess method SHOULD be used to "
       "completely remove all privileges between a subject and a target. "
       "On output, this property references an AuthorizedPrivilege "
       "instance that represents the resulting rights between the "
       "named Subject and the named Target. AuthorizedPrivilege instances "
       "used as a templates in this property SHOULD have a HostedDependency "
       "association to the PriviligeManagementService and SHOULD NOT have "
       "any AuthorizedTarget or AuthorizedSubject associations to it.") ]
       CIM_AuthorizedPrivilege REF Privilege );

      [Description (
          "This method revokes a specific AuthorizedPrivilege or "
          "all privileges for a particular target, subject, or "
          "subject/target pair.  If an AuthorizedPrivilege instance "
          "is left with no AuthorizedTarget associations, it SHOULD "
          "be deleted.  The successful completion of the method "
          "SHALL remove the directly or indirectly requested "
          "AuthorizedSubject, AuthorizedTarget and AuthorizedPrivilege "
          "instances."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..15999", "16000",
          "16001", "16002", "16003", "16004..32767", "32768..65535"}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Unsupported Privilege", "Unsupported Target",
          "Authorization Error", "Null parameter not supported",
          "Method Reserved", "Vendor Specific"} ]
   uint32 RemoveAccess (
       [IN, Description (
       "The Subject parameter is a reference to a ManagedElement "
       "instance (associated via AuthorizedSubject) for which "
       "privileges are to be revoked.") ]
       CIM_ManagedElement REF Subject,
       
       [IN, Description (
       "A reference to the AuthorizedPrivilege to be revoked.") ]      
       CIM_AuthorizedPrivilege REF Privilege,
       
       [IN, Description (
       "The Target parameter is a reference to a ManagedElement "
       "(associated via AuthorizedTarget) which will no longer "
       "be protected via the AuthorizedPrivilege.") ]
       CIM_ManagedElement REF Target );
};




// ===================================================================
// AuthenticationService
// ===================================================================
   [Version ( "2.8.0"), Description (
       "CIM_AuthenticationService verifies users' identities through "
       "some means.  These services are decomposed into a subclass "
       "that provides credentials to users and a subclass that "
       "provides for the verification of the validity of a credential "
       "and, perhaps, the appropriateness of its use for access to "
       "target resources.  The persistent state information used from "
       "one such verification to another is maintained in an instance "
       "of Identity class.") ]
class CIM_AuthenticationService : CIM_SecurityService {
};


// ===================================================================
// StorageHardwareIDManagementService
// ===================================================================
   [Version ( "2.8.0"), Description (
       "StorageHardwareIDManagementService provides methods for "
       "manipulating instances of StorageHardwareIDs and manipulating "
       "the trust of these IDs in the underlying storage system.") ]
class CIM_StorageHardwareIDManagementService : CIM_AuthenticationService {

      [Description (
          "This method creates a CIM_StorageHardwareID, it creates the "
          "association CIM_ConcreteDependency between this service and "
          "the new CIM_StorageHardwareID."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..0xFFF", "0x1000",
          "0x1001", "0x1003..0x7FFF", "0x8000.."}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "ID already created",
          "Hardware implementation does not support specified IDType",
          "Method Reserved", "Vendor Specific"} ]
 uint32 CreateStorageHardwareID (

      [IN, OUT(false), Description (
          "The ElementName of the new StorageHardwareID instance.") ]
      string ElementName,

       [IN, Description (
       "StorageID is the value used by the SecurityService to "
       "represent Identity - in this case, a hardware worldwide "
       "unique name.") ]
      string StorageID,

      [IN, OUT (false), Description (
          "The type of the StorageID property."),
          ValueMap {"1", "2", "3", "4"},
          Values {"Other", "PortWWN", "NodeWWN", "Hostname"} ]
      uint16 IDType,

      [IN, OUT (false), Description (
          "The type of the storage ID, when IDType is \"Other\".") ]
      string OtherIDType,

      [IN, OUT(false), Description (
          "REF to the StorageClientSettingData containing the OSType "
          "appropriate for this initiator.  If left NULL, the "
          "instrumentation assumes a standard OSType - i.e., that no "
          "OS-specific behavior for this initiator is defined.") ]
      CIM_StorageClientSettingData REF Setting,

      [IN(false), OUT, Description (
          "REF to the new StorageHardwareID instance." ) ]
      CIM_StorageHardwareID REF HardwareID );
    
// uint32 CreateStorageHardwareID (
//      [IN, OUT(false), Description (
//         "The ElementName of the new HardwareID instance.")]
//      string ElementName,
//      [IN, OUT(false), Description (
//        "ID is the value used by the SecurityService to represent "
//        "identity - in this case, a hardware worldwide unique name.") ]
//      string ID,
//      [IN, OUT (false), Description ("The type of the ID property."),
//         ValueMap {"1", "2", "3", "4"},
//         Values {"Other", "PortWWN", "NodeWWN", "Hostname"} ]
//      uint16 IDType,
//      [IN, OUT(false), Description (
//         "REF to the InitiatorSettingData with the OSType appropriate "
//         "for this initiator).  If left NULL, the instrumentation assumes "
//         "a standard OSType - no OS-specific behavior for this initiator.")]
//      CIM_InitiatorSettingData REF Setting,
//      [IN(false), OUT, Description (
//         "REF to the new Hardware ID instance." )]
//      CIM_StorageHardwareID REF HardwareID
//   );


      [Description (
          "This method deletes a named CIM_StorageHardwareID, and also "
          "tears down the associations that are no longer needed, "
          "including CIM_ConcreteDependency and "
          "CIM_AuthorizedSubject."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..0xFFF", "0x1000",
          "0x1001..0x7FFF", "0x8000.."}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Specified instance not found", "Method Reserved",
          "Vendor Specific"} ]
    uint32 DeleteStorageHardwareID(
                 [IN, Description (
             "The storage hardware ID to be deleted.")]
       CIM_StorageHardwareID REF HardwareID );


      [Description (
          "Create a group of StorageHardwareIDs as a new instance of "
          "SystemSpecificCollection.  This is useful to define a set "
          "of authorized subjects that can access volumes in a disk "
          "array.  This method allows the client to make a request of "
          "a specific Service instance to create the collection and "
          "provide the appropriate class name.  When these "
          "capabilities are standardized in CIM/WBEM, this method can "
          "be deprecated and intrinsic methods used.  In addition to "
          "creating the collection, this method causes the creation of "
          "the HostedCollection association (to this service's scoping "
          "system) and MemberOfCollection association to members of "
          "the IDs parameter."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..0xFFF", "0x1000",
          "0x1001", "0x1002", "0x1003..0x7FFF", "0x8000.."}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Invalid HardwareID instance",
          "Implementation does not support hardware ID collections",
          "Input hardware IDs cannot be used in same collection",
          "Method Reserved", "Vendor Specific"} ]
    uint32 CreateHardwareIDCollection (

        [IN, OUT (false), Description (
            "The ElementName to be assigned to the created "
            "collection.") ]
        string ElementName,

        [IN, OUT (false), Description (
            "Array of strings containing representations of references "
            "to StorageHardwareID instances that will become members of "
            "the new collection." ) ]
        string HardwareIDs[],

        [OUT, IN (false), Description (
            "The new instance of SystemSpecificCollection that is "
            "created.") ]
        CIM_SystemSpecificCollection REF Collection );

      [Description (
          "Create MemberOfCollection instances between the specified "
          "Collection and the StorageHardwareIDs.  This method allows "
          "the client to make a request of a specific Service instance "
          "to create the associations.  When these capabilities are "
          "standardized in CIM/WBEM, this method can be deprecated and "
          "intrinsic methods used."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..0xFFF", "0x1000",
          "0x1001", "0x1002", "0x1003..0x7FFF", "0x8000.."}, 
       Values { "Success", "Not Supported", "Unspecified Error", 
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Invalid LogicalDevice instance",
          "Implementation does not support device collections",
          "Input devices cannot be used in this collection",
          "Method Reserved", "Vendor Specific"} ]
    uint32 AddHardwareIDsToCollection (

       [IN, Description (
       "Array of strings containing representations of references "
       "to StorageHardwareID instances that will become members of "
       "the collection.") ]
        string HardwareIDs[],

       [IN, Description (
       "The Collection which groups the StorageHardwareIDs.") ]
        CIM_SystemSpecificCollection REF Collection );
};


// ===================================================================
// StorageConfigurationService
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "This service allows the active management of a Storage "
       "Server.  It allows jobs to be started for the creation, "
       "modification and deletion of storage objects (StoragePools and "
       "StorageVolumes).")]
class CIM_StorageConfigurationService : CIM_Service {
 
    [Description (
        "Starts a job to create (or modify) a StoragePool.  The "
        "StoragePool will be (or must be) scoped to the same System "
        "as this Service. One of the parameters for this method is "
        "Size. As an input parameter, Size specifies the desired "
        "size of the pool. As an output parameter, it specifies the "
        "size achieved. Space is taken from either or both of the "
        "specified input StoragePools and StorageExtents (InPools "
        "and InExtents). The capability requirements that the Pool "
        "must support are defined using the Goal parameter. If the "
        "requested pool size cannot be created, no action will be "
        "taken, the Return Value will be 4097/0x1001, and the "
        "output value of Size will be set to the nearest possible "
        "size. If 0 is returned, then the task completed successfully "
        "and the use of ConcreteJob was not required. If the task "
        "will take some time to complete, a ConcreteJob will be "
        "created and its reference returned in the output parameter "
        "Job."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", 
            "4096", "4097", "4098..32767", "32768..65535"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
            "In Use", "DMTF Reserved", 
            "Method Parameters Checked - Job Started",
            "Size Not Supported", "Method Reserved", 
            "Vendor Specific"} ]
    uint32 CreateOrModifyStoragePool ( 
        [IN, Description (
            "A end user relevant name for the pool being created. If "
            "NULL, then a system supplied default name can be used. "
            "The value will be stored in the 'ElementName' property "
            "for the created pool. If not NULL, this parameter "
            "will supply a new name when modifying an existing pool.") ]
        string ElementName,
        [OUT, IN(false), Description(
            "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description (
            "Reference to an instance of StorageSetting that defines "
            "the desired capabilities of the StoragePool. If set to a "
            "null value, the default configuration from the source "
            "pool will be used. If not NULL, this parameter will supply "
            "a new Goal setting when modifying an existing pool." ) ]
        CIM_StorageSetting REF Goal,
        [IN, OUT, Description(
            "As an input parameter this specifies the desired pool "
            "size in bytes. As an output parameter this specifies "
            "the size achieved."), Units ("Bytes") ] 
        uint64 Size,
        [IN, Description (
           "Array of strings containing representations of "
           "references to CIM_StoragePool instances, that are used "
           "to create the Pool or modify the source pools.") ]
        string InPools[],
        [IN, Description (
           "Array of strings containing representations of "
           "references to CIM_StorageExtent instances, that are used "
           "to create the Pool or modify the source extents.") ]
        string InExtents[],
        [IN, OUT, Description (
            "As an input parameter: if null, creates a new StoragePool. "
            "If not null, modifies the referenced Pool. When returned, "
            "it is a reference to the resulting StoragePool.") ] 
        CIM_StoragePool REF Pool);

    [Description (
        "Start a job to create (or modify) a specified element (for "
        "example a StorageVolume or StorageExtent) from "
        "a StoragePool. One of the parameters for this method is "
        "Size. As an input parameter, Size specifies the desired size "
        "of the element. As an output parameter, it specifies the size "
        "achieved. Space is taken from the input StoragePool. The "
        "desired settings for the element are specified by the Goal "
        "parameter. If the requested size cannot be created, no action "
        "will be taken, and the Return Value will be 4097/0x1001. "
        "Also, the output value of Size is set to the nearest possible "
        "size. If 0 is returned, the function completed successfully "
        "and no ConcreteJob instance was required.  If 4096/0x1000 is "
        "returned, a ConcreteJob will be started to create the "
        "element. The Job's reference will be returned in the "
        "output parameter Job."), 
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", 
            "4096", "4097", "4098..32767", "32768..65535"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
            "In Use",
            "DMTF Reserved", "Method Parameters Checked - Job Started",
            "Size Not Supported", "Method Reserved",
            "Vendor Specific"} ]
    uint32 CreateOrModifyElementFromStoragePool(
        [IN, Description (
            "A end user relevant name for the element being created. If "
            "NULL, then a system supplied default name can be used. The "
            "value will be stored in the 'ElementName' property for "
            "the created element. If not NULL, this parameter will "
            "supply a new name when modifying an existing element.") ]
        string ElementName,
        [IN, Description (
            "Enumeration indicating the type of element being created "
            "or modified. If the input parameter TheElement is "
            "specified when the operation is a 'modify', this type "
            "value must match the type of that instance."),
            ValueMap{"0", "1", "2", "3", "..", "32768..65535"},
            Values {"Unknown", "Reserved", "StorageVolume", 
                "StorageExtent", "DMTF Reserved", "Vendor Specific"} ]
        uint16 ElementType,
        [OUT, IN(false), Description(
            "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description(
            "The requirements for the element to maintain. If set to "
            "a null value, the default configuration from the source "
            "pool will be used. This parameter should be a reference "
            "to a Setting or Profile appropriate to the element being "
            "created. If not NULL, this parameter will supply a new "
            "Goal when modifying an existing element.") ]
        CIM_ManagedElement REF Goal,
        [IN, OUT, Description (
            "As an input parameter Size specifies the desired size. "
            "If not NULL, this parameter will supply a new size when "
            "modifying an existing element. As an output parameter "
            "Size specifies the size achieved."), 
            Units ("Bytes") ] 
        uint64 Size,
        [IN, Description(
            "The Pool from which to create the element. This parameter "
            "must be set to null if the input parameter TheElement is "
            "specified (in the case of a 'modify' operation).") ] 
        CIM_StoragePool REF InPool,
        [IN, OUT, Description (
            "As an input parameter: if null, creates a new element. If "
            "not null, then the method modifies the specified element. "
            "As an output parameter, it is a reference to the "
            "resulting element.") ] 
        CIM_LogicalElement REF TheElement);

    [Description (
        "Start a job to delete a StoragePool. The freed space is "
        "returned source StoragePools (indicated by AllocatedFrom"
        "StoragePool) or back to underlying storage extents.  If 0 is "
        "returned, the function completed successfully, and no "
        "ConcreteJob was required. If 4096/0x1000 is returned, a "
        "ConcreteJob will be started to delete the StoragePool. "
        "A reference to the Job is returned in the Job parameter."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
            "4097..32767", "32768..65535"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
            "In Use",
            "DMTF Reserved", "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 DeleteStoragePool (
        [OUT, IN(false), Description(
            "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description(
            "Reference to the pool to delete.") ] 
        CIM_StoragePool REF Pool);

    [Description (
        "Start a job to delete an element previously created from a "
        "StoragePool. The freed space is returned to the source "
        "StoragePool. If 0 is returned, the function completed "
        "successfully and no ConcreteJob was required. If 4096/0x1000 "
        "is returned, a ConcreteJob will be started to delete the "
        "element. A reference to the Job is returned in the Job "
        "parameter."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
            "4097..32767", "32768..65535"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
            "In Use",
            "DMTF Reserved", "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 ReturnToStoragePool(
        [OUT, IN(false), Description(
            "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description(
            "Reference to the element to return to the StoragePool.") ] 
        CIM_LogicalElement REF TheElement);

    [Description (
        "Start a job to create a new storage object which "
        "is a replica of the specified source storage object. "
        " (SourceElement). Note that using "
        "the input paramter, CopyType, this function can be used to "
        "instantiate the replica, and to create an ongoing "
        "association between the source and replica. If 0 is "
        "returned, the function completed successfully and no "
        "ConcreteJob instance is created. If 4096/0x1000 is returned, "
        "a ConcreteJob is started, a reference to which is "
        "returned in the Job output parameter."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
            "4097..32767", "32768..65535"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
            "In Use",
            "DMTF Reserved", "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 CreateReplica(
        [IN, Description (
            "A end user relevant name for the element being created. "
            "If NULL, then a system supplied default name can be used. "
            "The value will be stored in the 'ElementName' property "
            "for the created element.") ]
        string ElementName,
        [OUT, IN(false), Description(
            "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Required, Description(
            "The source storage object which may be a StorageVolume or "
            "storage object.") ]
        CIM_LogicalElement REF SourceElement,
        [OUT, IN(false), Description(
            "Reference to the created target storage element "
            "(i.e., the replica).") ]
        CIM_LogicalElement REF TargetElement,
        [IN, Description(
            "The definition for the StorageSetting to be maintained "
            "by the target storage object (the replica).") ]
        CIM_StorageSetting REF TargetSettingGoal,
        [IN, Description(
            "The underlying storage for the target element (the "
            "replica) will be drawn from TargetPool if specified, "
            "otherwise the allocation is implementation specific.") ] 
        CIM_StoragePool REF TargetPool,
        [IN, Description(
            "CopyType describes the type of copy that will be made. "
            "Values are: \n "
            "  Async: Create and maintain an asynchronous "
            "copy of the source. \n "
            "  Sync: Create and maintain a synchronized copy "
            "of the source. \n" 
            "  UnSyncAssoc: Create an unsynchronized copy and "
            "maintain an association to the source. \n "
            "  UnSyncUnAssoc: Create unassociated copy of the "
            "source element."),
            ValueMap {"2", "3", "4", "5", "..", "32768..65535"},
            Values {"Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
                "DMTF Reserved", "Vendor Specific"} ]
        uint16 CopyType);

   [Description (
        "Modify (or start a job to modify) the synchronization "
        "association between two storage objects. If 0 is returned, "
        "the function completed successfully and no ConcreteJob "
        "instance was created. If 0x1000 is returned, a ConcreteJob "
        "was started and a reference to this Job is returned in "
        "the Job output parameter. A return value of 1 indicates the "
        "method is not supported. All other values indicate some type "
        "of error condition."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
            "0x1001..0x7FFF", "0x8000..0xFFFF"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unspecified Error", "Timeout", "Failed", 
            "Invalid Parameter", "In Use", "DMTF Reserved", 
            "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 ModifySynchronization(
        [IN, Description(
            "Operation describes the type of modification to be made "
            "to the replica. Values are: \n "
            "  Detach: 'Forget' the synchronization between two "
            "storage objects. Start to treat the objects as "
            "independent. \n "
            "  Fracture: Suspend the synchronization between two "
            "storage objects. The association and (typically) changes "
            "are remembered to allow a fast resynchronization. This "
            "may be used during a backup cycle to allow one of the "
            "objects to be copied while the other remains in "
            "production. \n"
             "  Resync Replica: Re-establish the synchronization of "
             "a replica. This will negate the action of a previous "
             "Fracture operation. \n"
             "  Restore from Replica: Renew the contents of the "
             "original storage object from a replica. \n"
             "  Prepare: Get the link ready for a Resync operation to "
             "take place. Some implementations will require this "
             "operation to be invoked to keep the Resync operation "
             "as fast as possible.\n"
             "  Unprepare: Clear a prepared state if a Prepare is "
             "not to be followed by a Resync operation. \n"
             "  Quiesce: Some applications require notification so "
             "that they can ready the link for an operation. For "
             "example flush any cached data or buffered changes.\n"
             "  Unquiesce: Take the link from the quiesced state "
             "(without executing the intended operation.\n"
             "  Reset To Sync: Change the CopyType of the association "
             "to Sync (e.g., from the Async CopyType). \n"
             "  Reset To Async: Change the CopyType of the association "
             "to Async (e.g., from the Sync CopyType)."),
             ValueMap {"0","1","2", "3", "4", "5", "6", "7", "8", "9",
                 "10", "11", "..", "0x8000..0xFFFF"},
             Values {"DMTF Reserved", "DMTF Reserved", "Detach", 
                 "Fracture", "Resync Replica", "Restore from Replica",
                 "Prepare", "Unprepare", "Quiesce", "Unquiesce", 
                 "Reset To Sync", "Reset To Async", "DMTF Reserved", 
                 "Vendor Specific"} ]
        uint16 Operation,
        [OUT, IN(false), Description(
            "Reference to the job (may be null if the task completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description(
            "The referenced to the StorageSynchronized association "
            "describing the storage source/replica relationship.") ]
        CIM_StorageSynchronized REF Synchronization);


    [Description("Method to create a StorageSynchronized association. Optionally"
        "this association can be added to a ConsistencySet which has been"
    "created before. If the device doesn't support aggregating associations"
    "in ConsistencySets it is not permitted to pass in a ConsistencySet."
    "In order to find out what kind of ConsistencySets a device supports"
    "call GetSupportedSetTypes."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "..", "0x8000.."},
        Values {"Success", "Not Supported", "Unknown", "Timeout", 
        "Failed", "Invalid Parameter", 
            "CopyType not supported",
            "ConsistencySets not supported",
            "SynchronizedSets not supported",
            "System- and SyncedElement must be volumes if Set is passed in",
        "DMTF Reserved", "Vendor Specific"} ]
    uint32 CreateSynchronization(
        [IN, Description( "The source volume or ConsistencySet.") ]
        CIM_LogicalElement REF SystemElement,
        [IN, Description( "The target volume or ConsistencySet.") ]
        CIM_LogicalElement REF SyncedElement,
        [IN, Description( "The copy type of this copy relation. See"
    "StorageSynchronized.CopyType.") ]
        uint16 CopyType,
        [IN, Description( "The ElementName property of the StorageSynchronized"
    "to be created.") ]
        string ElementName,
        [IN, Description( "The set the synchronization will be added to. Must"
    "be a set whose MemberType is 1 (Aggregation of Synchronizations)."
    "This is an optional parameter.") ]
        CIM_SynchronizedSet REF Set, 
        [OUT, IN(false), Description( "The generated Synchronization.") ]
        CIM_StorageSynchronized REF CopyRelation );

    [Description("Method to delete a StorageSynchronized association. If the"
        "copy relation is part of a SynchronizedSet it may have to be removed"
    "from this set before this method is called by calling:"
    "ModifySynchronizedSet('Remove'). If there is a copy"
    "job started and not yet finished the association cannot be deleted"
    "until the job is completed. This method does not delete the"
    "connected volumes."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "..", "0x8000.."},
        Values {"Success", "Not Supported", "Unknown", "Timeout", 
        "Failed", "Invalid Parameter", 
            "Synchronization is member of SynchronizedSet",
            "Copy in process",
        "DMTF Reserved", "Vendor Specific"} ]
    uint32 DeleteSynchronization(
        [IN, Description( "The synchronization to be deleted.") ]
        CIM_StorageSynchronized REF CopyRelation );


    [Description("Method to create a SynchronizedSet. Some devices may not support"
    "SynchronizedSets. In order to find out if SynchronizedSets are supported"
    "call GetSupportedSetTypes."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "8", "..", "0x8000.."},
        Values {"Success", "Not Supported", "Unknown", "Timeout", 
        "Failed", "Invalid Parameter", 
            "CopyType not supported",
            "SynchronizedSets not supported",
        "DMTF Reserved", "Vendor Specific"} ]
    uint32 CreateSynchronizedSet(
        [IN, Description( "The copy type for associations in this set. See"
    "StorageSynchronized.CopyType. This parameter may be optional for"
    "some devices") ]
        uint16 CopyType, 
        [IN, Description( "The ElementName property of the SynchronizedSet that"
    "will be created. See SynchronizedSet.ElementName") ]
        string ElementName,
        [OUT, IN(false), Description( "The SynchronizedSet that was created.") ]
        CIM_SynchronizedSet REF Set );

    [Description("Method to delete a SynchronizedSet. If the set contains"
        "StorageSynchronized associations they have to be removed"
    "from this set before this method is called by calling:"
    "ModifySynchronizedSet('Remove')."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "0x8000.."},
        Values {"Success", "Not Supported", "Unknown", "Timeout", 
        "Failed", "Invalid Parameter", "SynchronizedSet is not empty",
        "DMTF Reserved", "Vendor Specific"} ]
    uint32 DeleteSynchronizedSet(
        [IN, Description( "The set that will be deleted.") ]
        CIM_SynchronizedSet REF Set );

    [Description("Method to manipulate SynchronizedSets."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "..", "0x1000",
            "0x1001..0x7777", "0x8000.."},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unknown", "Timeout", "Failed", "Invalid Parameter", 
        "Operatio not supported", "StorageSynchronized not in the Set",
        "StorageSynchronized already in a Set",
        "DMTF Reserved", 
            "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 ModifySynchronizedSet(
        [IN, Description( "Operation describes the type of modification to be"
            "made to the SynchronizedSet. Values are: "
            "  Add: Add the passed StorageElement to the set."
            "  Remove: Remove the passed StorageElement from the set."
            "  Delete Synchronizations: All StorageSynchronized associations"
        "in this SynchronizedSet are deleted."
             "  Fracture Replicas: Suspend the synchronizationw between "
             "all storage objects in the set. The associations and "
             "(typically) changes are remembered to allow a fast "
             "resynchronization. This may be used during "
             "a backup cycle to allow one of the objects to be "
             "copied while the other remains in production. \n"
             "  Resync Replicas: Re-establish the synchronizations of "
             "all replicas in the set. If CopyType is Sync or Async, this will "
             "negate the action of a previous Fracture operation. \n"
             "  Restore from Replica: Renew the contents of "
             "the original storage objects from tbe  replicas."
         "  Prepare All: Prepare the participating volumes for"
         "a point in time copy."),
            ValueMap {"0","1","2", "3", "4", "5", "6", "7", "8", "..", "0x8000.."},
            Values {" DMTF Reserved", "DMTF Reserved", "Add", "Remove",  
                "Delete Synchronizations", "Fracture Replicas", "Resync Replicas",  
                "Restore From Replicas", "Prepare All", "DMTF Reserved", "Vendor Specific"} ]
        uint16 Operation,
        [OUT, IN(false), Description( "Reference to the job (may be null if job completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Description( "The reference to the SynchronizedSet describing the set to be modified.") ]
        CIM_SynchronizedSet REF SynchronizedSet,
        [IN, Required, Description( "The storage object being added or removed.") ]
        CIM_LogicalElement REF StorageElement);

    [Description("This method returns the types of sets that are supported by the device."),
        ValueMap {"0", "1", "2", "3", "4", "..", "0x8000.."},
        Values {"Success", "Not Supported", "Unknown", "Timeout", 
        "Failed", "DMTF Reserved", "Vendor Specific"} ]
    uint64 GetSupportedSetTypes(
        [OUT, IN(false), Description("The array of supported types."),
            ValueMap {"0","1"},
            Values {"ConsistencySets", "SynchronizedSets"} ]  
    uint16 SupportedTypes[] );
    
    [Experimental, Description (
        "Create (or start a job to create) a StorageSynchronized "
        "relationship between two existing storage objects.   Note "
        "that using the input parameter, CopyType, this function can "
        "be used to to create an ongoing association between the source"
        "and replica. If 0 is returned, the function completed "
        "successfully and no ConcreteJob instance is created. "
        "If 0x1000 is returned, a ConcreteJob is started, a reference "
        "to which is returned in the Job output parameter."
        "A return value of 1 indicates the method is not supported. "
        "All other values indicate some type of error condition."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
            "0x1001..0x7FFF", "0x8000..0xFFFF"},
        Values {"Job Completed with No Error", "Not Supported", 
            "Unspecified Error", "Timeout", "Failed", 
            "Invalid Parameter", "In Use",
            "DMTF Reserved", "Method Parameters Checked - Job Started",
            "Method Reserved", "Vendor Specific"} ]
    uint32 AttachReplica(
        [OUT, IN(false), Description(
            "Reference to the job (may be null if the task "
            "completed).") ]
        CIM_ConcreteJob REF Job,
        [IN, Required, Description(
            "The source storage object which may be a StorageVolume or "
            "other storage object") ]
        CIM_ManagedElement REF SourceElement,
        [IN, Description(
            "Reference to the target storage element "
            "(i.e., the replica).") ]
        CIM_ManagedElement REF TargetElement,
        [IN, Description(
            "CopyType describes the type of Synchronized relationship "
            "that will be created. "
            "Values are: \n "
            "  Async: Create and maintain an asynchronous "
            "copy of the source. \n "
            "  Sync: Create and maintain a synchronized copy "
            "of the source. \n" 
            "  UnSyncAssoc: Create an unsynchronized copy and "
            "maintain an association to the source. \n "
            "  UnSyncUnAssoc: Create unassociated copy of the "
            "source element."),
            ValueMap {"2", "3", "4", "5", "..", "0x8000..0xFFFF"},
            Values {"Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
                "DMTF Reserved", "Vendor Specific"} ]
        uint16 CopyType);
    

};


// ===================================================================
// ControllerConfigurationService
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The ControllerConfigurationService provides methods that allow "
       "a client to manipulate LUN Masking in a storage system.")]
class CIM_ControllerConfigurationService : CIM_Service {
      [Description (
          "This method creates an appropriate subclass of "
          "ProtocolController.  In addition to its role of controlling "
          "downstream devices, a ProtocolControl is used to provide a "
          "central management point for access control with respect to "
          "those devices.  Certain storage system implementations "
          "across multiple vendors require permissions to be "
          "established atomically with the creation of a "
          "ProtocolController.  This method provides this capability "
          "via the Privilege and Identity properties.  By supplying "
          "appropriate information in those properties, this method "
          "will assure that appropriate AuthorizedTarget and "
          "AuthorizedSubject associations, (as defined in the User and "
          "Security Model), are instantiated to restrict access to the "
          "logical devices 'behind' it.  \n"
          "If multiple target ports are specified in the Ports input "
          "parameter, all expose the same view (i.e., have the same "
          "unit numbers and permissions).  This method does not create "
          "the port instances, but does create "
          "ProtocolControllerForPort associations between the "
          "specified ports and the new ProtocolController.  The new "
          "ProtocolController is defined to be weak to the same System "
          "as the ControllerConfigurationService."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6..4095", "4096",
          "4097", "4098", "4099..32767", "32768..65535" }, 
       Values { "Success", "Not Supported", "Unspecified Error",
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "ID Parameter Missing or Not Unique",
          "Hardware Implementation Requires Null Ports Parameter",
          "Busy", "Method Reserved", "Vendor Specific" }]
   uint32 CreateProtocolControllerWithPorts (
       [IN, OUT (false), Description (
       "The string to be used in the ElementName of the new "
       "ProtocolController."),
       ModelCorrespondence {"CIM_ProtocolController.ElementName"} ]
       string ElementName,
         [IN, Description (
             "Array of strings containing representations of "
             "references to instances of CIM_LogicalPort (or subclass) "
             "instances.  This is the list of target ports that are "
             "associated to the ProtocolController.  "
             "ProtocolControllerForPort associations are created by "
             "the instrumentation associating the new "
             "ProtocolController to these ports.  If this parameter is "
             "null, then all ports in the storage system (this "
             "Service's 'scoping' System and all its ComponentCS "
             "Systems) are attached to the new ProtocolController.")]
       string Ports[],
       [IN, OUT (false), Description (
       "The protocol type for the new ProtocolController."),
       ValueMap {"0", "1", "2"},
       Values {"Unknown", "Other", "SCSI"},
       ModelCorrespondence {"CIM_SCSIProtocolController"} ]
       uint16 Protocol,
         [IN, Description (
             "Reference to a CIM_Privilege (or subclass) instance to "
             "be used as a template.  If supplied, it has a 1:1 "
             "correspondence with the Identity parameter and this "
             "method will atomically create the new ProtocolController "
             "instance and related AuthorizedPrivilege, "
             "AuthorizedTarget and AuthorizedSubject instances.  \n"
             "Note: if ProtocolControllerRequiresAuthorizedIdentity is "
             "true, then the Identity/Privilege pair MUST be "
             "specified.  If false, then the Identity/Privilege pair "
             "MUST NOT be specified."), 
          ModelCorrespondence { "CIM_ControllerConfigurationService." 
             "CreateProtocolControllerWithPorts.Identity" }]
   CIM_Privilege REF Privilege,

         [Description (
             "Reference to a CIM_ManagedElement (or subclass) "
             "instance.  This ManagedElement MUST be either a "
             "CIM_Identity, or a CIM_Collection (or subclass, eg.  "
             "SystemSpecificCollection, Role, or Group) that has "
             "CIM_Identities as MemberOfCollection.  If "
             "ProtocolControllerMaskingCapabilities.ProtocolControllerSupportsCollection "
             "is false, the reference MUST be to a CIM_Identity (or "
             "subclass).  If present, it has a 1:1 correspondence with "
             "the Privilege property.  If present, this method will "
             "atomically create the new ProtocolController instance "
             "and instantiate a missing AuthorizedSubject association "
             "between the Privilege/Identity pair; and instantiate an "
             "AuthorizedTarget association between the "
             "AuthorizedPrivilege and the new ProtocolController.  \n"
             "Note: if ProtocolControllerRequiresAuthorizedIdentity is "
             "true, then at least the Identity/Privilege pair MUST be "
             "specified."), 
          ModelCorrespondence { "CIM_ControllerConfigurationService." 
             "CreateProtocolControllerWithPorts.Privilege" }]
      CIM_ManagedElement REF Identity,

      [IN(false), OUT, Description (
          "A reference to the new ProtocolController that is created.") ]
   CIM_ProtocolController REF ProtocolController);

    [Description (
         "The method deletes an instance of ProtocolController and all "
         "associations in which this ProtocolController is referenced."),
         ValueMap {"0", "1", "2", "3", "4", "5", "6..4095",
            "4096", "4097", "4098..32767", "32768..65535"},
         Values {"Success", "Not Supported",
            "Unspecified Error", "Timeout", "Failed", "Invalid Parameter",
            "DMTF Reserved", 
            "LogicalDevices Associated to Other ProtocolControllers Not Deleted",
            "Busy", "Method Reserved", "Vendor Specific"} ]
    uint32 DeleteProtocolController (
        [IN, OUT (false), Description (
           "The ProtocolController to be deleted.") ]
        CIM_ProtocolController REF ProtocolController,
        [IN, OUT (false), Description (
             "If true, the management instrumentation provider will "
             "also delete 'child' ProtocolControllers (i.e., those "
             "defined as Dependent references in instances of "
             "AssociatedProtocolController where this "
             "ProtocolController is the Antecedent reference).  Also, "
             "all direct associations involving the 'child' "
             "ProtocolControllers will be removed.")]
        boolean DeleteChildrenProtocolControllers,
         [IN, Description (
             "If true, the management instrumentation provider will "
             "also delete LogicalDevice instances associated via "
             "ProtocolControllerForUnit, to this ProtocolController "
             "and its children.  (Note that 'child' controllers will "
             "only be affected if the "
             "DeleteChildrenProtocolControllers input parameter is "
             "TRUE).  LogicalDevice instances are only deleted if "
             "there are NO remaining ProtocolControllerForUnit "
             "associations, to other ProtocolControllers.")]
        boolean DeleteUnits 
    );

    [Description (
        "This method associates a LogicalDevice subclass (specifically "
        "a StorageVolume or MediaAccessDevice subclass) to the "
        "referenced ProtocolController.  The association is persisted "
        "as an instance of ProtocolControllerForUnit.  The management "
        "instrumentation provider must verify that the logical unit "
        "numbers (defined using the DeviceNumber input parameter) are "
        "unique for the ProtocolController.  When the Protocol"
        "Controller is actively masking a device (i.e. is part of an "
        "AuthorizedTarget association), the provider should update the "
        "access configuration in the underlying hardware as "
        "appropriate." ),
        ValueMap {"0", "1", "2", "3", "4", "5", "6..4095",
            "4096", "4097", "4098", "4099", "4100", "4101..32767", 
            "32768..65535"},
        Values {"Success", "Not Supported",
            "Unspecified Error", "Timeout", "Failed", "Invalid Parameter",
            "DMTF Reserved", "Invalid LogicalDevice Instance",
            "Device Number Conflict", 
            "DeviceNumber Parameter Must Be Provided",
            "Hardware Implementation Requires Null DeviceNumber",
            "Busy", "Method Reserved", "Vendor Specific"} ]
    uint32 AttachDevice (
      [IN, OUT (false), Description (
         "The ProtocolController instance.") ]
      CIM_ProtocolController REF ProtocolController,
      [IN, OUT (false), Description (
         "The LogicalDevice instance to attach.") ]
      CIM_LogicalDevice REF Device,
         [IN, OUT, Description (
             "The number assigned to "
             "ProtocolControllerForUnit.DeviceNumber (if supported by "
             "the hardware).  Hardware support is indicated by "
             "ProtocolControllerMaskingCapabilities.ClientSelectableDeviceNumbers).  "
             "If the hardware does not support setting the number, but "
             "the DeviceNumber has not been established in an existing "
             "ProtocolControllerForDevice subclass, then this "
             "parameter's value will be used.  If the DeviceNumber has "
             "been established, then the current number will be "
             "reused."), 
          ModelCorrespondence { 
             "CIM_ProtocolControllerForUnit.DeviceNumber" }]
      string DeviceNumber 
    );

    [Description (
         "This method removes the ProtocolControllerForDevice "
         "association subclass between the ProtocolController and a "
         "LogicalDevice, such as a StorageVolume or a MediaAccessDevice. "
         "When the ProtocolController is actively masking a device (i.e. "
         "is part of an AuthorizedTarget association, the management "
         "instrumentation provider should update the hardware access "
         "configuration when DetachDevice is called." ),
        ValueMap {"0", "1", "2", "3", "4", "5", "6..4095",
            "4096", "4097", "4098..32767", "32768..65535"},
        Values {"Success", "Not Supported",
            "Unspecified Error", "Timeout", "Failed", "Invalid Parameter",
            "DMTF Reserved",
            "LogicalDevice Instance not Associated with Controller",
            "Busy", "Method Reserved", "Vendor Specific"} ]
    uint32 DetachDevice (
      [IN, OUT (false), Description (
         "The ProtocolController instance.") ]
      CIM_ProtocolController REF ProtocolController,
      [IN, OUT (false), Description (
         "The LogicalDevice instance to detach.") ]
      CIM_LogicalDevice REF Device 
    );
};


// ===================================================================
// ClusteringService
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "ClusteringService represents the functionality provided by a "
       "Cluster.  For example, failover functionality may be modeled "
       "as a Service of a failover Cluster.")]
class CIM_ClusteringService : CIM_Service {
      [Description (
          "AddNode brings a new ComputerSystem into a Cluster.  The "
          "node to be added is specified as a parameter to the "
          "method.  The return value should be 0 if the Computer "
          "System is successfully added, 1 if the method is not "
          "supported and any other number if an error occurred.  In a "
          "subclass, the set of possible return codes could be "
          "specified, using a ValueMap qualifier on the method.  The "
          "strings to which the ValueMap contents are 'translated' may "
          "also be specified in the subclass as a Values array "
          "qualifier.")]
   uint32 AddNode ( 
         [IN, Description (
             "The node to add to the cluster.")]
      CIM_ComputerSystem ref CS);
        
      [Description (
          "EvictNode removes a ComputerSystem from a Cluster.  The "
          "node to be evicted is specified as a parameter to the "
          "method.  The return value should be 0 if the ComputerSystem "
          "is successfully evicted, 1 if the method is not supported "
          "and any other number if an error occurred.  In a subclass, "
          "the set of possible return codes could be specified, using "
          "a ValueMap qualifier on the method.  The strings to which "
          "the ValueMap contents are 'translated' may also be "
          "specified in the subclass as a Values array qualifier.")]
   uint32 EvictNode ( 
         [IN, Description (
             "The node to remove from the cluster.")]
      CIM_ComputerSystem ref CS); 
};


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


// ===================================================================
// ComputerSystem
// ===================================================================
   [Version ( "2.7.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.  The "
          "NameFormat property identifies how the ComputerSystem Name "
          "is generated.  The NameFormat ValueMap qualifier defines "
          "the various mechanisms for assigning the name.  Note that "
          "another name can be assigned and used for the "
          "ComputerSystem that better suit a business, using the "
          "inherited ElementName property."), 
       ValueMap { "Other", "IP", "Dial", "HID", "NWA", "HWA", "X25",
          "ISDN", "IPX", "DCC", "ICD", "E.164", "SNA", "OID/OSI",
          "WWN", "NAA" }]
    string NameFormat;
   
      [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."), 
       MaxLen ( 256 ), ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_ComputerSystem.IdentifyingDescriptions" }]
    string OtherIdentifyingInfo[];
    
      [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."), 
       ArrayType ( "Indexed" ), 
       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).  \n"
          "A clarification is needed with respect to the value 17 "
          "(\"Mobile User Device\").  An example of a dedicated user "
          "device is a mobile phone or a barcode scanner in a store "
          "that communicates via radio frequency.  These systems are "
          "quite limited in functionality and programmability, and are "
          "not considered 'general purpose' computing platforms.  "
          "Alternately, an example of a mobile system that is 'general "
          "purpose' (i.e., is NOT dedicated) is a hand-held computer.  "
          "Although limited in its programmability, new software can "
          "be downloaded and its functionality expanded by the user."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
          "20" }, 
       Values { "Not Dedicated", "Unknown", "Other", "Storage",
          "Router", "Switch", "Layer 3 Switch",
          "Central Office Switch", "Hub", "Access Server", "Firewall",
          "Print", "I/O", "Web Caching", "Management", "Block Server",
          "File Server", "Mobile User Device", "Repeater",
          "Bridge/Extender", "Gateway" }, 
       MappingStrings { "MIB.IETF|MIB-II.sysServices" },
          ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_ComputerSystem.OtherDedicatedDescriptions" }]
    uint16 Dedicated[];

      [Description (
          "A string describing how or why the system is dedicated when "
          "the Dedicated array includes the value 2, \"Other\"."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_ComputerSystem.Dedicated" }]
    string OtherDedicatedDescriptions[];

      [Description (
          "If enabled (value = 4), the ComputerSystem 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;
    
      [Deprecated { "CIM_PowerManagementCapabilities.PowerCapabilities" 
          }, Description (
          "An enumerated array describing the power management "
          "capabilities of the ComputerSystem.  The use of this "
          "property has been deprecated.  Instead, the Power "
          "Capabilites property in an associated PowerManagement "
          "Capabilities class should be used."), 
       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[];
    
      [Deprecated { "CIM_PowerManagementService.SetPowerState" }, 
       Description (
          "Sets the power state of the computer.  The use of this "
          "method has been deprecated.  Instead, use the SetPowerState "
          "method in the associated PowerManagementService class.")]
    uint32 SetPowerState(
         [IN, Description (
             "The Desired state for the COmputerSystem."), 
          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, Description (
             "Time 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.")]
      datetime Time); 
};


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


// ===================================================================
// LogicalDevice
// ===================================================================
   [Abstract, Version ( "2.8.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_EnabledLogicalElement {

      [Key, Propagated ( "CIM_System.CreationClassName" ), 
       Description (
          "The scoping System's CreationClassName."), 
       MaxLen ( 256 )]
    string SystemCreationClassName;
    
      [Key, Propagated ( "CIM_System.Name" ), Description (
          "The scoping System's Name."), 
       MaxLen ( 256 )]
    string SystemName;
    
      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance.  When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
    string CreationClassName;
    
      [Key, Description (
          "An address or other identifying information to uniquely "
          "name the LogicalDevice."), 
       MaxLen ( 64 )]
    string DeviceID;
    
      [Deprecated { "CIM_PowerManagementCapabilities" }, Description (
          "Boolean indicating that the Device can be power managed.  "
          "The use of this property has been deprecated.  Instead, the "
          "existence of an associated PowerManagementCapabilities "
          "class (associated using the ElementCapabilities "
          "relationhip) indicates that power management is supported.")]
    boolean PowerManagementSupported;
    
      [Deprecated { "CIM_PowerManagementCapabilities.PowerCapabilities" 
          }, Description (
          "An enumerated array describing the power management "
          "capabilities of the Device.  The use of this property has "
          "been deprecated.  Instead, the PowerCapabilites property in "
          "an associated PowerManagementCapabilities class should be "
          "used."), 
       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.5",
          "MIB.IETF|HOST-RESOURCES-MIB.hrDeviceStatus",
          "MIF.DMTF|Host Device|001.5" }, 
       ModelCorrespondence { "CIM_LogicalDevice.AdditionalAvailability" 
          }]
    uint16 Availability;
    
      [Deprecated { "CIM_EnabledLogicalElement.EnabledState" }, 
       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.  StatusInfo has been "
          "deprecated in lieu of a more clearly named property with "
          "additional enumerated values (EnabledState), that is "
          "inherited from ManagedSystemElement.  \n"
          "If a Device is (\"Enabled\")(value=3), it has been powered "
          "up, and is configured and operational.  The Device may or "
          "may not be functionally active, depending on whether its "
          "Availability (or AdditionalAvailability) indicate that it "
          "is (\"Running/Full Power\")(value=3) or (\"Off line\") "
          "(value=8).  In an enabled but offline mode, a Device may be "
          "performing out-of-band requests, such as running "
          "Diagnostics.  If (\"Disabled\") StatusInfo value=4), a "
          "Device can only be \"enabled\" or powered off.  In a "
          "personal computer environment, (\"Disabled\") means that "
          "the Device's driver is not available in the stack.  In "
          "other environments, a Device can be disabled by removing "
          "its configuration file.  A disabled device is physically "
          "present in a System and consuming resources, but can not be "
          "communicated with until a load of a driver, a load of a "
          "configuration file or some other \"enabling\" activity has "
          "occurred."), 
       ValueMap { "1", "2", "3", "4", "5" }, 
       Values { "Other", "Unknown", "Enabled", "Disabled",
          "Not Applicable" }, 
       MappingStrings { "MIF.DMTF|Operational State|006.4" }]
    uint16 StatusInfo;
    
      [Deprecated { "CIM_DeviceErrorData.LastErrorCode" }, 
       Description (
          "LastErrorCode captures the last error code reported by the "
          "LogicalDevice.")]
    uint32 LastErrorCode;
    
      [Deprecated { "CIM_DeviceErrorData.ErrorDescription" }, 
       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;
    
      [Deprecated { "CIM_ManagedSystemElement.OperationalStatus" }, 
       Description (
          "ErrorCleared is a boolean property indicating that the "
          "error reported in LastErrorCode is now cleared.")]
    boolean ErrorCleared;
    
      [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."), 
       MaxLen ( 256 ), ArrayType ( "Indexed" ), 
       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;
    
      [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."), 
       ArrayType ( "Indexed" ), 
       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[];
    
      [Deprecated { "No value" }, Description (
          "The MaxQuiesceTime property has been deprecated.  When "
          "evaluating the use of Quiesce, it was determine that this "
          "single property is not adequate for describing when a "
          "device will automatically exit a quiescent state.  In fact, "
          "the most likely scenario for a device to exit a quiescent "
          "state was determined to be based on the number of "
          "outstanding requests queued rather than on a maximum time.  "
          "This will be re-evaluated and repositioned later.  \n"
          "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;
    
      [Deprecated { "CIM_PowerManagementService.SetPowerState" }, 
       Description (
          "Sets the power state of the Device.  The use of this method "
          "has been deprecated.  Instead, use the SetPowerState method "
          "in the associated PowerManagementService class.")]
   uint32 SetPowerState( 
         [IN, Description (
             "The power state to set."), 
          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, Description (
             "Time 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.")]
      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(); 

      [Deprecated { "CIM_EnabledLogicalElement.RequestStateChange" }, 
       Description (
          "The EnableDevice method has been deprecated in lieu of the "
          "more general RequestStateChange method that directly "
          "overlaps with the functionality provided by this method.  \n"
          "Requests that the LogicalDevice be enabled (\"Enabled\" "
          "input parameter = TRUE) or disabled (= FALSE).  If "
          "successful, the Device's StatusInfo/EnabledState properties "
          "should reflect the desired state (enabled/disabled).  Note "
          "that this method's function overlaps with the "
          "RequestedState property.  RequestedState was added to the "
          "model to maintain a record (i.e., a persisted value) of the "
          "last state request.  Invoking the EnableDevice method "
          "should set the RequestedState property appropriately.  \n"
          "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, Description (
             "If TRUE enable the device, if FALSE disable the device.")]
      boolean Enabled); 

      [Deprecated { "CIM_EnabledLogicalElement.RequestStateChange" }, 
       Description (
          "The OnlineDevice method has been deprecated in lieu of the "
          "more general RequestStateChange method that directly "
          "overlaps with the functionality provided by this method.  \n"
          "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 an "
          "EnabledState/StatusInfo of \"Enabled\" 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.  \n"
          "Note that this method's function overlaps with the "
          "RequestedState property.  RequestedState was added to the "
          "model to maintain a record (i.e., a persisted value) of the "
          "last state request.  Invoking the OnlineDevice method "
          "should set the RequestedState property appropriately.")]
   uint32 OnlineDevice( 
         [IN, Description (
             "If TRUE, take the device online, if FALSE, take the "
             "device OFFLINE.")]
      boolean Online); 

      [Deprecated { "CIM_EnabledLogicalElement.RequestStateChange" }, 
       Description (
          "The QuiesceDevice method has been deprecated in lieu of the "
          "more general RequestStateChange method that directly "
          "overlaps with the functionality provided by this method.  \n"
          "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 an "
          "EnabledStatus/StatusInfo of \"Enabled\".  For example, if "
          "quiesced, a Device may then be offlined for diagnostics, or "
          "disabled for power off and hot swap.  For the method to "
          "\"unquiesce\" a Device, that Device should have an "
          "Availability (or AdditionalAvailability) of \"Quiesced\" "
          "(value=21) and an EnabledStatus/StatusInfo of \"Enabled\".  "
          "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, Description (
             "If set to TRUE then cleanly cease all activity, if FALSE "
             "resume activity.")]
      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();       
};  


// ===================================================================
// Controller
// ===================================================================
[Abstract, Version ("2.7.0"), Description (
    "Controller is a superclass for grouping the miscellaneous "
    "control-related Devices that exist. Examples of Controllers "
    "are SCSIControllers, USBControllers, SerialControllers, ... "
    "The Controller class is an abstraction for Devices with a "
    "single protocol stack, which exist to control communications "
    "(data, control, and reset) with devices.") ]
class CIM_Controller : CIM_LogicalDevice {
    [Experimental, Description(
        "System level port or bus identification number")]
    uint64 PortNumber;
    
    [Description (
        "Time of last reset of the Controller.") ]
    datetime TimeOfLastReset;

    [Description (
        "The protocol used by the Controller to access 'controlled' "
        "Devices."),
        ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
            "11", "12", "13", "14", "15", "16", "17", "18", "19",
            "20", "21", "22", "23", "24", "25", "26", "27", "28",
            "29", "30", "31", "32", "33", "34", "35", "36", "37",
            "38", "39", "40", "41", "42", "43", "44", "45", "46", 
            "47"},
        Values {"Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI",
            "Flexible Diskette", "1496", "SCSI Parallel Interface",
            // 10
            "SCSI Fibre Channel Protocol", "SCSI Serial Bus Protocol",
            "SCSI Serial Bus Protocol-2 (1394)", 
            "SCSI Serial Storage Architecture", "VESA", "PCMCIA",        
            "Universal Serial Bus", "Parallel Protocol", "ESCON",
            "Diagnostic", 
            // 20
            "I2C", "Power", "HIPPI", "MultiBus", "VME",
            "IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5",
            "IEEE 802.3 10BASE2", 
            // 30
            "IEEE 802.3 1BASE5",
            "IEEE 802.3 10BROAD36", "IEEE 802.3 100BASEVG",
            "IEEE 802.5 Token-Ring", "ANSI X3T9.5 FDDI", "MCA", 
            "ESDI", "IDE", "CMD", "ST506", 
            // 40
            "DSSI", "QIC2", 
            "Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)", 
            "FIR (fast infrared)", "SIR (serial infrared)", 
            "IrBus"}, 
        MappingStrings {"MIF.DMTF|Bus Port|004.2",
            "MIF.DMTF|Disks|003.3"},
        ModelCorrespondence {"CIM_Controller.ProtocolDescription"} ]
    uint16 ProtocolSupported;
 
    [Description (
        "Maximum number of directly addressable entities supported "
        "by this Controller.  A value of 0 should be used if the "
        "number is unknown or unlimited."),
        MappingStrings {"MIF.DMTF|Bus Port|004.9"} ]
    uint32 MaxNumberControlled;  
 
    [Description (
        "A free form string providing more information related "
        "to the ProtocolSupported by the Controller."),
        ModelCorrespondence {"CIM_Controller.ProtocolSupported"},
        MappingStrings {"MIF.DMTF|Bus Port|004.3"} ]
     string ProtocolDescription;

    [Description (
        "Set to true if the Controller represents an authorization target.") ]
    boolean AuthorizationView;

    [Description (
        "Set to true if the Controller reporesents a default global access "
        "definitition rather than a authorization for a specific subject.") ]
    boolean DefaultGlobalAccess;

    [Description (
        "CreateView clones a CIM_Controller with AuthorizationView set true. "
        "This new controller is used as an AuthorizationTarget.  The provider "
        "creates a ConreteIdentity between the original and new Controller. "
        "If multiple target ports are passed in, all expose the same view "
        "(i.e., the same devices with the same unit numbers and permission.)"),
        ValueMap {"0", "1", "2", "3", "4", "5", "..",
            "0x1000", "0x1001", "0x1003..0x7777", "0x8000.."},
        Values {"Success", "Not Supported",
            "Unknown", "Timeout", "Failed", "Invalid Parameter",
            "DMTF Reserved",
            "Input controller must have AUthorizationView false",
            "Hardware implmentation requires null",
            "Method Reserved",
            "Vendor Specific"} ]
    uint32 CreateView (
      [IN, OUT (false), Description (
         "Array of strings containing representations of references to "
         "CIM_LogicalPort (or subclass) instances. This is the list "
         "of target ports that are associated to the controller for"
         "the new authorization view.  ConcreteIdentity associations "
         "are created by the provider associating the new controller "
         "to these ports.  If this parameter is null, then all ports "
         "in the scoping system are attached to the new controller. ") ]
      string Ports[],
      [OUT, IN (false), Description (
         "The new Controller with AuthorizationView set to true.") ]
      CIM_Controller REF View );

    [Description (
         "Delete the controller and associations from CreateView.")]
    uint32 DeleteView (
      [IN, OUT (false), Description (
         "The controller created by CreateView.") ]
      CIM_Controller REF Controller );

    [Description (
         "Associate a LogicalDevice subclass to this controller. Keeps "
         "the client from needing separate logic for different "
         "ControlledBy subclasses used by different types of hardware. ") ]
    uint32 AttachDevice (
      [IN, OUT (false), Description (
         "The LogicalDevice instance to attach.") ]
      CIM_LogicalDevice REF Device );

    [Description (
         "Remove the ControlledBy association subclass between this "
         "controller and device.  Keeps the client from needing separate "
         "logic for different ControlledBy subclasses used by different "
         "types of hardware. ") ]
    uint32 RemoveDevice (
      [IN, OUT (false), Description (
         "The LogicalDevice instance to attach.") ]
      CIM_LogicalDevice REF Device );
};


// ===================================================================
// StorageExtent
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "StorageExtent describes the capabilities and management of the "
       "various media that exist to store data and allow data "
       "retrieval.  This superclass could be used to represent the "
       "various components of RAID (Hardware or Software) or as a raw "
       "logical extent on top of physical media.")] 
class CIM_StorageExtent : CIM_LogicalDevice {

    [Description ("Type of data organization used."), 
        ValueMap {"0", "1", "2", "3", "4"},
        Values {"Other", "Unknown", "Fixed Block", "Variable Block", 
            "Count Key Data"} ]
    uint16 DataOrganization;

    [Description (
        "A free form string describing the media and/or its use."),
        MappingStrings {
            "MIB.IETF|HOST-RESOURCES-MIB.hrStorageDescr"} ]
    string Purpose;

    [Description (
        "Access describes whether the media is readable (value=1), "
        "writeable (value=2), or both (value=3). \"Unknown\" (0) "
        "and \"Write Once\" (4) can also be defined."),
        ValueMap {"0", "1", "2", "3", "4"},
        Values {"Unknown", "Readable", "Writeable", 
            "Read/Write Supported", "Write Once"} ]
    uint16 Access;

    [Description (
        "ErrorMethodology is a free-form string describing "
        "the type of error detection and correction supported "
        "by this StorageExtent.") ]
    string ErrorMethodology;

    [Description (
        "Size in bytes of the blocks which form this StorageExtent. "
        "If variable block size, then the maximum block size in bytes "
        "should be specified. If the block size is unknown or if a "
        "block concept is not valid (for example, for AggregateExtents, "
        "Memory or LogicalDisks), enter a 1."), 
        Units ("Bytes"),
        MappingStrings {"MIF.DMTF|Host Storage|001.4", 
            "MIB.IETF|HOST-RESOURCES-MIB.hrStorageAllocationUnits",
            "MIF.DMTF|Storage Devices|001.5"} ]
    uint64 BlockSize;

    [Description (
        "Total number of logically contiguous blocks, of size Block"
        "Size, which form this Extent. The total size of the Extent "
        "can be calculated by multiplying BlockSize by NumberOfBlocks. "
        "If the BlockSize is 1, this property is the total size of the "
        "Extent."),
        MappingStrings {"MIF.DMTF|Host Storage|001.5", 
            "MIB.IETF|HOST-RESOURCES-MIB.hrStorageSize"} ]
     uint64 NumberOfBlocks;

      [Description (
          "The maximum number of blocks, of size BlockSize, which are "
          "available for consumption when layering StorageExtents "
          "using the BasedOn association.  This property only has "
          "meaning when this StorageExtent is an Antecedent reference "
          "in a BasedOn relationship.  For example, a StorageExtent "
          "could be composed of 120 blocks.  However, the Extent "
          "itself may use 20 blocks for redundancy data.  If another "
          "StorageExtent is BasedOn this Extent, only 100 blocks would "
          "be available to it.  This information ('100 blocks is "
          "available for consumption') is indicated in the "
          "ConsumableBlocks property.")]
     uint64 ConsumableBlocks;

     [Description (
         "True indicates that the underlying StorageExtent(s) "
         "participate in a StorageRedundancyGroup.") ]
     boolean IsBasedOnUnderlyingRedundancy;

      [Description (
          "Boolean set to TRUE if the Storage is sequentially accessed "
          "by a MediaAccessDevice.  A TapePartition is an example of a "
          "sequentially accessed StorageExtent.  StorageVolumes, Disk "
          "Partitions and LogicalDisks represent randomly accessed "
          "Extents.")]
    boolean SequentialAccess;
        
    [Description (
        "StorageExtents have additional status information beyond that "
        "captured in the OperationalStatus and other properties, "
        "inherited from ManagedSystemElement. This additional "
        "information (for example, \"Protection Disabled\", value=9) "
        "is captured in the VolumeStatus property."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
            "10", "11", "12", "13", "14", "15..32767", "32768..65535"},
        Values {"Other", "Unknown", "None/Not Applicable", "Broken", 
            "Data Lost", "Dynamic Reconfig", "Exposed", 
            "Fractionally Exposed", "Partially Exposed", 
            "Protection Disabled", "Readying", "Rebuild", 
            "Recalculate", "Spare in Use", "Verify In Progress",
            "DMTF Reserved", "Vendor Reserved"} ]
    uint16 ExtentStatus[];
    
    [Description (
           "Indicates whether or not there exists no single point of "
           "failure."), 
        ModelCorrespondence { 
          "CIM_StorageSetting.NoSinglePointOfFailure" }]
    boolean NoSinglePointOfFailure;
 
    [Description (
        "Number of complete copies of data currently maintained."),
     ModelCorrespondence {"CIM_StorageSetting.DataRedundancyGoal",
       "CIM_StorageSetting.DataRedundancyMax",
       "CIM_StorageSetting.DataRedundancyMin"} ]
    uint16 DataRedundancy;
 
      [Description (
          "How many physical packages can currently fail without data "
          "loss.  For example, in the storage domain, this might be "
          "disk spindles."), 
       ModelCorrespondence { 
          "CIM_StorageSetting.PackageRedundancyGoal",
          "CIM_StorageSetting.PackageRedundancyMax",
          "CIM_StorageSetting.PackageRedundancyMin" }]
    uint16 PackageRedundancy;
 
      [Description (
          "Current value for Delta reservation.  This is a percentage "
          "that specifies the amount of space that should be reserved "
          "in a replica for caching changes."), 
       Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ), 
       ModelCorrespondence { "CIM_StorageSetting.DeltaReservationGoal",
          "CIM_StorageSetting.DeltaReservationMax",
          "CIM_StorageSetting.DeltaReservationMin" }]
   uint8 DeltaReservation;


      [Description (
          "If true, \"Primordial\" indicates that the containing "
          "System does not have the ability to create or delete this "
          "operational element.  This is important because "
          "StorageExtents are assembled into higher-level abstractions "
          "using the BasedOn association.  Although the higher-level "
          "abstractions can be created and deleted, the most basic, "
          "(i.e.  primordial), hardware-based storage entities "
          "cannot.  They are physically realized as part of the "
          "System, or are actually managed by some other System and "
          "imported as if they were physically realized.  In other "
          "words, a Primordial StorageExtent exists in, but is not "
          "created by its System and conversely a non-Primordial "
          "StorageExtent is created in the context of its System.  For "
          "StorageVolumes, this property will generally be false.  One "
          "use of this property is to enable algorithms that aggregate "
          "StorageExtent.ConsumableSpace across all, StorageExtents "
          "but that also want to distinquish the space that underlies "
          "Primordial StoragePools.  Since implementations are not "
          "required to surface all Component StorageExtents of a "
          "StoragePool, this information is not accessible in any "
          "other way.")]    
   boolean Primordial = false;
};


// ===================================================================
// StorageVolume
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A StorageVolume is an Extent that is presented to the "
       "Operating System (for example, by a hardware RAID cabinet), to "
       "a File System (for example, by a software volume manager) or "
       "to another entity.  StorageVolumes do NOT participate in "
       "StorageRedundancy Groups.  They are directly Realized in "
       "hardware or are the end result of assembling lower level "
       "Extents.")]
class CIM_StorageVolume : CIM_StorageExtent {

      [Override ( "Name" ), Description (
          "A unique identifier for the Volume."), 
       MappingStrings { "ANSI|T10|SCSI SPC-3|8.6" }, 
       ModelCorrespondence { "CIM_StorageVolume.NameFormat" }]
    string Name;

      [Experimental, Description (
          "Note - this property originally touched on two concepts "
          "that are now separated into this property and "
          "NameNamespace.  Values 2,3,4,5,6, and 8 are retained for "
          "backwards compatibility but are deprecated in lieu of the "
          "corresponding values in CIM_StorageVolume.NameNamespace.  "
          "Format of the Name property.  Values are (per SCSI SPC-3): "
          "2 = VPD Page 83, NAA IEEE Registered Extended (VPD83NAA6) "
          "(DEPRECATED) 3 = VPD Page 83, NAA IEEE Registered "
          "(VPD83NAA5) (DEPRECATED) 4 = VPD Page 83, EIU-64 "
          "(VPD83Type2) (DEPRECATED) 5 = VPD Page 83, T10 Vendor "
          "Identification (VPD83Type1) (DEPRECATED) 6 = VPD Page 83, "
          "Vendor Specific (VPD83Type0) (DEPRECATED) 7 = Serial "
          "Number/Vendor/Model (SNVM) SNVM is 3 strings representing "
          "the vendor name, product name within the vendor namespace, "
          "and the serial number within the model namespace.  Strings "
          "are delimited with a '+'.  Spaces may be included and are "
          "significant.  The serial number is the text representation "
          "of the serial number in hexadecimal upper case.  The "
          "represent the vendor and model ID from SCSI Inquiry data, "
          "the vendor field should be 8 characters wide and the "
          "product field should be 16 characters wide.  For example, "
          "'ACME +SUPER DISK +124437458' 8 = Node WWN (for single "
          "LUN/controller) (NodeWWN) (DEPRECATED) 9 = NAA as a generic "
          "format.  See http: "
          "//standards.ieee.org/regauth/oui/tutorials/fibrecomp_id.html "
          "Formatted as 16 or 32 unseparated uppercase hex "
          "characters (2 per binary byte).  For example "
          "'21000020372D3C73' 10 = EUI as a generic format.  See http: "
          "//standards.ieee.org/regauth/oui/tutorials/EUI64.html "
          "Formatted as 16 unseparated uppercase hex characters (2 per "
          "binary byte) 11 = T10 vendor identifier format as returned "
          "by SCSI Inquiry VPD page 83, identifier type 2.  See T1- "
          "SPC-3 specification.  The 8-byte ASCII vendor ID from the "
          "T10 registry followed by a vendor specific ASCII "
          "identifier; spaces are permitted.  For non SCSI volumes, "
          "'SNVM' may be the most appropriate choice."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10" }, 
       Values { "Unknown", "Other", "VPD83NAA6", "VPD83NAA5",
          "VPD83Type2", "VPD83Type1", "VPD83Type0", "SNVM",
          "NodeWWNNAA", "EUI64", "T10VID" }, 
       ModelCorrespondence { "CIM_StorageVolume.Name",
          "CIM_StorageVolume.OtherNameFormat" }]
   uint16 NameFormat;

      [Description (
          "The preferred source for volume names is SCSI VPD Page 83 "
          "responses.  Page 83 returns a list of identifiers for "
          "various device elements.  The metadata for each identifier "
          "includes an Association field, identifiers with association "
          "of 0 apply to volumes.  Page 83 supports several namespaces "
          "specified in the Type field in the identifier metadata.  "
          "See SCSI SPC-3 specification.  2 = VPD Page 83, Type 3 NAA "
          "(NameFormat should be NAA) 3 = VPD Page 83, Type 2 EUI64 "
          "(NameFormat EUI) 4 = VPD Page 83, Type 1 T10 Vendor "
          "Identification; (NameFormat T10) Less preferred namespaces "
          "from other interfaces: 5 = VPD page 80, Serial number "
          "(NameFormat should be Other) 6 = FC NodeWWN (NameFormat "
          "should be NAA or EUI) 7 = Serial Number/Vendor/Model "
          "(NameFormat should be SNVM)"), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7" }, 
       Values { "Unknown", "Other", "VPD83Type3", "VPD83Type2",
          "VPD83Type1", "VPD80", "NodeWWN", "SNVM" }, 
       MappingStrings { "INCITS|T10|SCSI SPC-3|Vital Product Data " 
          "Parameters" }, 
       ModelCorrespondence { "CIM_StorageVolume.Name",
          "CIM_StorageVolume.OtherNameNamespace" }]
   uint16 NameNamespace;

      [Description (
          "A string describing the namespace of the Name property when "
          "NameNamespace includes the value 1, \"Other\"."), 
       ModelCorrespondence { "CIM_StorageVolume.NameNamespace" }]
   string OtherNameNamespace;


      [Description (
          "A string describing the format of the Name property when "
          "NameFormat includes the value 1, \"Other\"."), 
       ModelCorrespondence { "CIM_StorageVolume.NameFormat" }]
   string OtherNameFormat;
};


// ===================================================================
// LogicalPort
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The abstraction of a port or connection point of a Device.  "
       "This object should be instantiated when the Port has "
       "independent management characteristics from the Device that "
       "includes it.  Examples are a Fibre Channel Port and a USB "
       "Port.")]
class CIM_LogicalPort : CIM_LogicalDevice {

    [Description ("The bandwidth of the Port in Bits per Second."), 
        Units ("Bits per Second") ]
    uint64 Speed;

    [Description (
        "The maximum bandwidth of the Port in Bits per Second."), 
        Units ("Bits per Second") ]
    uint64 MaxSpeed;

      [Write, Description (
          "The requested bandwidth of the Port in Bits per Second.  "
          "The actual bandwidth is reported in LogicalPort.Speed."), 
       Units ( "Bits per Second" ), 
       ModelCorrespondence { "CIM_LogicalPort.Speed" }]
    uint64 RequestedSpeed;

      [Description (
          "In some circumstances, a LogicalPort may be identifiable as "
          "a front end or back end port.  An example of this would be "
          "a storage array which might have back end ports to "
          "communicate with disk drives and front end ports to "
          "communicate with hosts.  If there is no restriction on the "
          "use of the port, then the value should be set to 'not "
          "restricted'."), 
       ValueMap { "0", "2", "3", "4" }, 
       Values { "Unknown", "Front-end only", "Back-end only",
          "Not restricted" }]
    uint16 UsageRestriction;
};


// ===================================================================
// NetworkPort
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "NetworkPort is the logical representation of network "
       "communications hardware - a physical connector and the "
       "setup/operation of the network chips, at the lowest layers of "
       "a network stack.")]
class CIM_NetworkPort : CIM_LogicalPort {
    
    [Override ("Speed"), Description (
        "The current bandwidth of the Port in Bits per Second. "
        "For ports that vary in bandwidth or for those where "
        "no accurate estimation can be made, this property should "
        "contain the nominal bandwidth."),
        Units ("Bits per Second"), 
        MappingStrings {"MIB.IETF|MIB-II.ifSpeed", 
            "MIF.DMTF|Network Adapter 802 Port|001.5"} ]
    uint64 Speed;
 
    [Description (
        "PortType is defined to force consistent naming of the 'type' "
        "property in subclasses and to guarantee unique enum values "
        "for all instances of NetworkPort.  When set to 1 (\"Other\"), "
        "related property OtherPortType contains a string description "
        "the of the port's type.  A range of values, DMTF_Reserved, "
        "has been defined that allows subclasses to override and "
        "define their specific port types."),
        ValueMap {"0", "1", "2", "3..15999", "16000..65535"},
        Values {"Unknown", "Other", "Not Applicable", "DMTF Reserved", 
            "Vendor Reserved"},
        ModelCorrespondence {"CIM_NetworkPort.OtherNetworkPortType"} ]
    uint16 PortType;
    
    [Description (
        "Describes the type of module, when PortType is "
        "set to 1 (\"Other\")."),
        ModelCorrespondence {"CIM_NetworkPort.PortType"} ]
    string OtherNetworkPortType;
    
    [Description (
        "NetworkPorts are often numbered relative to either a logical "
        "modules or a network element.") ]
    uint16 PortNumber;
    
      [Description (
          "An enumeration of the types of links.  When set to 1 "
          "(\"Other\"), the related property OtherLinkTechnology "
          "contains a string description of the link's type."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "Unknown", "Other", "Ethernet", "IB", "FC", "FDDI",
          "ATM", "Token Ring", "Frame Relay", "Infrared", "BlueTooth",
          "Wireless LAN" }, 
       ModelCorrespondence { "CIM_NetworkPort.OtherLinkTechnology" }]
    uint16 LinkTechnology;
    
    [Description (
        "A string value describing LinkTechnology when it "
        "is set to 1, \"Other\"."),
        ModelCorrespondence {"CIM_NetworkPort.LinkTechnology"} ]
    string OtherLinkTechnology;
 
      [Description (
          "PermanentAddress defines the network address hardcoded into "
          "a port.  This 'hardcoded' address may be changed via "
          "firmware upgrade or software configuration.  If so, this "
          "field should be updated when the change is made.  "
          "PermanentAddress should be left blank if no 'hardcoded' "
          "address exists for the NetworkAdapter."), 
       MaxLen ( 64 ), 
       MappingStrings { "MIF.DMTF|Network Adapter 802 Port|001.2" }]       
    string PermanentAddress;
 
      [Description (
          "An array of strings indicating the network addresses for "
          "the port."), 
       MaxLen ( 64 ), 
       MappingStrings { "MIF.DMTF|Network Adapter 802 Port|001.3" }]
    string NetworkAddresses[]; 
 
      [Description (
          "Boolean indicating that the port is operating in full "
          "duplex mode.")]
    boolean FullDuplex;
 
    [Description ( 
        "A boolean indicating whether the NetworkPort is capable " 
        "of automatically determining the speed or other "
        "communications characteristics of the attached network "
        "media.") ] 
    boolean AutoSense;
 
    [Description (
        "The maximum transmission unit (MTU) that can be supported."), 
        Units ("Bytes") ] 
    uint64 SupportedMaximumTransmissionUnit;
 
    [Description (
        "The active or negotiated maximum transmission unit (MTU) that "
        "can be supported."), 
        Units ("Bytes") ] 
    uint64 ActiveMaximumTransmissionUnit;
};


// ===================================================================
// FCPort
// ===================================================================
[Version ("2.7.1"), Description (
    "Capabilities and management of a Fibre Channel Port Device.") ] 
class CIM_FCPort : CIM_NetworkPort {
    
    [Override("PortType"), Description (
        "The specific mode currently enabled for the Port. "
        "The values: \"N\" = Node Port, \"NL\" = Node Port "
        "supporting FC arbitrated loop, \"E\" = Expansion Port "
        "connecting fabric elements (for example, FC switches), "
        "\"F\" = Fabric (element) Port, \"FL\" = Fabric (element) "
        "Port supporting FC arbitrated loop, \"B\" = Bridge "
        "and \"G\" = Generic Port.  "
        "PortTypes are defined in the ANSI X3 standards. "
        "When set to 1 (\"Other\"), the related property "
        "OtherPortType contains a string description of "
        "the port's type."),
        ValueMap {"0", "1", "10", "11", "12", "13", "14", "15", 
            "16", "17", "18", "16000..65535"},
        Values {"Unknown", "Other", "N", "NL", "F/NL", "Nx", "E", 
            "F", "FL", "B", "G", "Vendor Reserved"} ]
    uint16 PortType;

    [Description (
        "An array of integers indicating the Fibre Channel Classes of "
        "Service that are supported. The active COS are indicated in "
        "ActiveCOS."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"},
        Values {"Unknown", "1", "2", "3", "4", "5", "6", "F"} ]
    uint16 SupportedCOS[];

    [Description (
        "An array of integers indicating the Classes of Service that "
        "are active. The Active COS is indicated in ActiveCOS."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"},
        Values {"Unknown", "1", "2", "3", "4", "5", "6", "F"},
        ModelCorrespondence {"CIM_FCPort.SupportedCOS"}  ]
    uint16 ActiveCOS[];

      [Description (
          "An array of integers indicating the Fibre Channel FC-4 "
          "protocols supported.  The protocols that are active and "
          "running are indicated in the ActiveFC4Types property."), 
       ValueMap { "0", "1", "4", "5", "8", "9", "17", "18", "19", "21",
          "22", "23", "25", "26", "27", "28", "32", "34", "36", "64",
          "80", "81", "82", "88", "96", "255" }, 
       Values { "Unknown", "Other", "ISO/IEC 8802 - 2 LLC",
          "IP over FC", "SCSI - FCP", "SCSI - GPP", "IPI - 3 Master",
          "IPI - 3 Slave", "IPI - 3 Peer", "CP IPI - 3 Master",
          "CP IPI - 3 Slave", "CP IPI - 3 Peer", "SBCCS Channel",
          "SBCCS Control Unit", "FC-SB-2 Channel",
          "FC-SB-2 Control Unit",
          "Fibre Channel Services (FC-GS, FC-GS-2, FC-GS-3)", "FC-SW",
          "FC - SNMP", "HIPPI - FP", "BBL Control",
          "BBL FDDI Encapsulated LAN PDU",
          "BBL 802.3 Encapsulated LAN PDU", "FC - VI", "FC - AV",
          "Vendor Unique" }]
    uint16 SupportedFC4Types[];

      [Description (
          "An array of integers indicating the Fibre Channel FC-4 "
          "protocols currently running.  A list of all protocols "
          "supported is indicated in the SupportedFC4Types property."), 
       ValueMap { "0", "1", "4", "5", "8", "9", "17", "18", "19", "21",
          "22", "23", "25", "26", "27", "28", "32", "34", "36", "64",
          "80", "81", "82", "88", "96", "255" }, 
       Values { "Unknown", "Other", "ISO/IEC 8802 - 2 LLC",
          "IP over FC", "SCSI - FCP", "SCSI - GPP", "IPI - 3 Master",
          "IPI - 3 Slave", "IPI - 3 Peer", "CP IPI - 3 Master",
          "CP IPI - 3 Slave", "CP IPI - 3 Peer", "SBCCS Channel",
          "SBCCS Control Unit", "FC-SB-2 Channel",
          "FC-SB-2 Control Unit",
          "Fibre Channel Services (FC-GS, FC-GS-2, FC-GS-3)", "FC-SW",
          "FC - SNMP", "HIPPI - FP", "BBL Control",
          "BBL FDDI Encapsulated LAN PDU",
          "BBL 802.3 Encapsulated LAN PDU", "FC - VI", "FC - AV",
          "Vendor Unique" }, 
       ModelCorrespondence { "CIM_FCPort.SupportedFC4Types" }]
    uint16 ActiveFC4Types[];
};


// ===================================================================
// ProtocolController
// ===================================================================
   [Abstract, Version ( "2.8.0" ), Description (
       "ProtocolController is a superclass for grouping controllers "
       "that are used to control the operation and function of "
       "sophisticated devices that instantiate a protocol such as "
       "SCSI.  Simpler 'bus' and device controllers are modeled using "
       "the CIM_Controller class.")]
class CIM_ProtocolController : CIM_LogicalDevice {

    [Description (
        "Maximum number of Units that can be controlled by or accessed "
        "through this ProtocolController.") ]
    uint32 MaxUnitsControlled;  

};


// ===================================================================
// SCSIProtocolController
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "SCSIProtocolController is a type of ProtocolController, "
       "managing a SCSI interface.")]
class CIM_SCSIProtocolController : CIM_ProtocolController {
};


// ===================================================================
// MediaAccessDevice
// ===================================================================
[Version ("2.6.0"), Description (
    "A MediaAccessDevice represents the ability to access one or "
    "more media and use this media to store and retrieve data.") ] 
class CIM_MediaAccessDevice : CIM_LogicalDevice {

      [Description (
          "Capabilities of the MediaAccessDevice.  For example, the "
          "Device may support \"Random Access\", removeable media and "
          "\"Automatic Cleaning\".  In this case, the values 3, 7 and "
          "9 would be written to the array.  \n"
          "Several of the enumerated values require some explanation: "
          "1) Value 11, Supports Dual Sided Media, distinguishes a "
          "Device that can access both sides of dual sided Media, from "
          "a Device that reads only a single side and requires the "
          "Media to be flipped; and, 2) Value 12, Predismount Eject "
          "Not Required, indicates that Media does not have to be "
          "explicitly ejected from the Device before being accessed by "
          "a PickerElement."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "12" }, 
       Values { "Unknown", "Other", "Sequential Access",
          "Random Access", "Supports Writing", "Encryption",
          "Compression", "Supports Removeable Media",
          "Manual Cleaning", "Automatic Cleaning", 
          // 10      
          "SMART Notification", "Supports Dual Sided Media",
          "Predismount Eject Not Required" }, 
       MappingStrings { "MIF.DMTF|Storage Devices|001.9",
          "MIF.DMTF|Storage Devices|001.11",
          "MIF.DMTF|Storage Devices|001.12", "MIF.DMTF|Disks|003.7",
          "MIF.DMTF|Host Disk|001.2", "MIF.DMTF|Host Disk|001.4" },
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_MediaAccessDevice.CapabilityDescriptions" }]
    uint16 Capabilities[];

      [Description (
          "An array of free-form strings providing more detailed "
          "explanations for any of the AccessDevice features indicated "
          "in the Capabilities array.  Note, each entry of this array "
          "is related to the entry in the Capabilities array that is "
          "located at the same index."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_MediaAccessDevice.Capabilities" }]
    string CapabilityDescriptions[];

    [Description (
        "ErrorMethodology is a free-form string describing "
        "the type(s) of error detection and correction supported "
        "by this Device.") ]
    string ErrorMethodology;

      [Description (
          "A free form string indicating the algorithm or tool used by "
          "the device to support compression.  If it is not possible "
          "or not desired to describe the compression scheme (perhaps "
          "because it is not known), recommend using the following "
          "words: \"Unknown\" to represent that it is not known "
          "whether the device supports compression capabilities or "
          "not, \"Compressed\" to represent that the device supports "
          "compression capabilities but either its compression scheme "
          "is not known or not disclosed, and \"Not Compressed\" to "
          "represent that the devices does not support compression "
          "capabilities.")]
    string CompressionMethod;

      [Description (
          "When the MediaAccessDevice supports multiple individual "
          "Media, this property defines the maximum number which can "
          "be supported or inserted.")]
    uint32 NumberOfMediaSupported;

      [Description (
          "Maximum size, in KBytes, of media supported by this "
          "Device.  KBytes is interpreted as the number of bytes "
          "multiplied by 1000 (NOT the number of bytes multiplied by "
          "1024)."), 
       MappingStrings { "MIF.DMTF|Sequential Access Devices|001.2",
          "MIF.DMTF|Host Disk|001.5" }]
    uint64 MaxMediaSize;

    [Description ("Default block size, in bytes, for this Device."),
        Units ("Bytes") ]
    uint64 DefaultBlockSize;

    [Description (
        "Maximum block size, in bytes, for media accessed by this "
        "Device."),
        Units ("Bytes") ]
    uint64 MaxBlockSize;

    [Description (
        "Minimum block size, in bytes, for media accessed by this "
        "Device."),
        Units ("Bytes") ]
    uint64 MinBlockSize;

    [Description (
        "Boolean indicating that the MediaAccessDevice needs cleaning. " 
        "Whether manual or automatic cleaning is possible is indicated "
        "in the Capabilities array property.") ]
    boolean NeedsCleaning;

    [Description (
        "True indicates that the media is locked in the Device "
        "and can not be ejected. For non-removeable Devices, this "
        "value should be true.") ]
    boolean MediaIsLocked;

    [Description (
        "An enumeration indicating the operational security defined "
        "for the MediaAccessDevice. For example, information that "
        "the Device is \"Read Only\" (value=4) or \"Boot Bypass\" "
        "(value=6) can be described using this property."), 
        ValueMap {"1", "2", "3", "4", "5", "6", "7"}, 
        Values {"Other", "Unknown", "None", "Read Only", "Locked Out",
            "Boot Bypass", "Boot Bypass and Read Only"}, 
        MappingStrings {"MIF.DMTF|Disks|003.22"} ]
    uint16 Security;

    [Description (
        "The date and time on which the Device was last cleaned.") ]
    datetime LastCleaned;

      [Description (
          "Time in milliseconds to move from the first location on the "
          "Media to the location that is furthest with respect to "
          "time.  For a DiskDrive, this represents full seek + full "
          "rotational delay.  For TapeDrives, this represents a search "
          "from the beginning of the tape to the most physically "
          "distant point.  (The end of a tape may be at its most "
          "physically distant point, but this is not necessarily "
          "true.)"), 
       Units ( "MilliSeconds" )]
    uint64 MaxAccessTime;

      [Description (
          "The sustained data transfer rate in KB/sec that the Device "
          "can read from and write to a Media.  This is a sustained, "
          "raw data rate.  Maximum rates or rates assuming compression "
          "should not be reported in this property."), 
       Units ( "KiloBytes per Second" )]
    uint32 UncompressedDataRate;

    [Description (
        "Time in milliseconds from 'load' to being able to read "
        "or write a Media. For example, for DiskDrives, this is "
        "the interval between a disk not spinning to the disk "
        "reporting that it is ready for read/write (ie, the disk "
        "spinning at nominal speeds). For TapeDrives, this is "
        "the time from a Media being injected to reporting that "
        "it is ready for an application. This is usually at the "
        "tape's BOT area."), 
        Units ("MilliSeconds") ]
    uint64 LoadTime;

    [Description (
        "Time in milliseconds from being able to read or write a "
        "Media to its 'unload'. For example, for DiskDrives, "
        "this is the interval between a disk spinning at nominal "
        "speeds and a disk not spinning. For TapeDrives, this is "
        "the time for a Media to go from its BOT to being fully "
        "ejected and accessible to a PickerElement or human "
        "operator."), 
        Units ("MilliSeconds") ]
    uint64 UnloadTime;

    [Description (
        "For a MediaAccessDevice that supports removable Media, "
        "the number of times that Media have been mounted for "
        "data transfer or to clean the Device. For Devices "
        "accessing nonremovable Media, such as hard disks, "
        "this property is not applicable and should be set to 0."),
        Counter ]
    uint64 MountCount;

    [Description (
        "For a MediaAccessDevice that supports removable Media, "
        "the most recent date and time that Media was mounted "
        "on the Device. For Devices accessing nonremovable Media, "
        "such as hard disks, this property has no meaning and is "
        "not applicable.") ]
    datetime TimeOfLastMount;

    [Description (
        "For a MediaAccessDevice that supports removable Media, "
        "the total time (in seconds) that Media have been mounted "
        "for data transfer or to clean the Device. For Devices "
        "accessing nonremovable Media, such as hard disks, "
        "this property is not applicable and should be set to 0.") ]
    uint64 TotalMountTime;

    [Description (
        "Defines 'Units' relative to its use in the property, "
        "MaxUnitsBeforeCleaning. This describes the criteria used "
        "to determine when the MediaAccessDevice should be cleaned."),
        ModelCorrespondence {
            "CIM_MediaAccessDevice.MaxUnitsBeforeCleaning",
            "CIM_MediaAccessDevice.UnitsUsed"} ]
    string UnitsDescription;
    
    [Description (
        "An unsigned integer indicating the maximum 'units' "
        "that can be used, with respect to the AccessDevice, "
        "before the Device should be cleaned. The property, "
        "UnitsDescription, defines how 'units' should be "
        "interpreted."),
        ModelCorrespondence {
            "CIM_MediaAccessDevice.UnitsDescription"} ]
    uint64 MaxUnitsBeforeCleaning;

    [Description (
        "An unsigned integer indicating the currently used " 
        "'units' of the AccessDevice, helpful to describe "
        "when the Device may require cleaning. The property, "
        "UnitsDescription, defines how 'units' should be "
        "interpreted."),
        Gauge,
        ModelCorrespondence {
            "CIM_MediaAccessDevice.UnitsDescription",
            "CIM_MediaAccessDevice.MaxUnitsBeforeCleaning"} ]
    uint64 UnitsUsed;

    [Description (
        "Method to lock and unlock the media in a removeable Access"
        "Device. The method takes one parameter as input - a boolean "
        "indicating whether to lock or unlock. TRUE indicates that "
        "the media should be locked in the Device, FALSE indicates "
        "that the media should be unlocked. The method returns 0 if "
        "successful, 1 if not supported, and any other value if an "
        "error occurred. The set of possible return codes should be "
        "specified in a ValueMap qualifier on the method. The strings "
        "to which the ValueMap contents are 'translated' should be "
        "specified as a Values array qualifier on the method.") ]
    uint32 LockMedia (
        [IN] 
        boolean Lock);
};


// ===================================================================
// DiskDrive
// ===================================================================
[Version ("2.6.0"), Description (
    "Capabilities and managment of a DiskDrive, a subtype of "
    "MediaAccessDevice.") ] 
class CIM_DiskDrive : CIM_MediaAccessDevice {
};


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


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


// ===================================================================
// ObjectManagerCommunicationMechanism
// ===================================================================
[Version ("2.7.0"), Description ( 
    "The class, ObjectManagerCommunicationMechanism, describes " 
    "access to an ObjectManager. It describes a protocol and " 
    "data encoding that can be used for communication. When all " 
    "instances of this class are enumerated for an ObjectManager " 
    "(using the CommMechanismForManager association), all possible " 
    "protocol and encoding schemes will be known. Also, specific " 
    "capabilities (for example, basic read or query) that are " 
    "supported in the protocol/encoding are described - using the " 
    "ProfilesSupported property.") ] 
class CIM_ObjectManagerCommunicationMechanism :  CIM_ServiceAccessPoint { 

    [Required, Description ( 
        "CommunicationMechanism describes an encoding and protocol " 
        "which can be used to communicate with the ObjectManager. " 
        "At this time, only one encoding and protocol are standardized " 
        "by the DMTF - \"CIM-XML\". If this is supported by an " 
        "ObjectManager, the specified string should be indicated. " 
        "Other 'standard' strings may be defined. In addition, a vendor "
        "specific encoding/protocol string may be used."), 
        ValueMap {"0", "1", "2"}, 
        Values {"Unknown", "Other", "CIM-XML"}, 
        ModelCorrespondence { "CIM_ObjectManagerCommunicationMechanism." 
          "OtherCommunicationMechanismDescription" }] 
    uint16 CommunicationMechanism; 

    [Description ( 
        "A free-form string providing a description of the " 
        "supported protocols when 1, \"Other\", is specified in " 
        "the CommunicationMechanism."), 
        ModelCorrespondence { 
        "CIM_ObjectManagerCommunicationMechanism.CommunicationMechanism"} ] 
    string OtherCommunicationMechanismDescription; 

      [Required, Description (
          "Enumerated array describing the types of operations "
          "supported by the ObjectManager, using this "
          "encoding/protocol.  The enumeration is based on the "
          "Functional Profiles defined for conformance in the DMTF "
          "document, Specification for CIM Operations over HTTP."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" }, 
       Values { "Unknown", "Other", "Basic Read", "Basic Write",
          "Schema Manipulation", "Instance Manipulation",
          "Association Traversal", "Query Execution",
          "Qualifier Declaration", "Indications" },
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_ObjectManagerCommunicationMechanism." 
          "FunctionalProfileDescriptions" }]
    uint16 FunctionalProfilesSupported[]; 

      [Description (
          "Free-form strings providing descriptions of the supported "
          "operations of the object manager.  Entries in the array are "
          "correlated with those in the ProfilesSupported array.  An "
          "entry in this Descriptions array MUST be provided when 1, "
          "\"Other\", is specified in the ProfilesSupported array."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_ObjectManagerCommunicationMechanism." 
          "FunctionalProfilesSupported" }]
    string FunctionalProfileDescriptions[];

    [Required, Description ( 
        "Boolean indicating whether the ObjectManager supports " 
        "multiple operation requests (TRUE) or only simple requests " 
        "(FALSE).") ] 
    boolean MultipleOperationsSupported; 

    [Required, Description ( 
        "Enumerated array describing the types of authentication " 
        "supported by the ObjectManager, using the encoding/protocol. " 
        "specified in the property, CommunicationMEchanism. "
        "The defined values represent the authentication defined in " 
        "the DMTF document, Specification for CIM Operations over HTTP."),
        ValueMap {"0", "1", "2", "3", "4"}, 
        Values {"Unknown", "Other", "None", "Basic", "Digest"},
        ArrayType ("Indexed"),
        ModelCorrespondence {    
           "CIM_ObjectManagerCommunicationMechanism."
              "AuthenticationMechanismDescriptions"} ] 
    uint16 AuthenticationMechanismsSupported[]; 

    [Description (
        "Free-form strings providing descriptions of the supported "
        "mechanisms.  Entries in this array are correlated with those "
        "in the AuthenticationMechanismsSupported array. An entry in "
        "this Descriptions array MUST be provided when 1, \"Other\", "
        "is specified in AuthenticationMechanismsSupported."),
        ArrayType ("Indexed"),
        ModelCorrespondence {
           "CIM_ObjectManagerCommunicationMechanism."
              "AuthenticationMechanismsSupported"} ]
    string AuthenticationMechanismDescriptions[];

    [Required, Description (
        "Provides the protocol version for this service "
        "access point. Version information MUST be in "
        "the form of M.N, where M is a numeric that describes "
        "the Major version and N is a numeric that describes "
        "the minor version.") ]
    string Version;
};


// ===================================================================
// CIMXMLCommunicationMechanism
// ===================================================================
[Version ("2.6.0"), Description ( 
    "This class specializes ObjectManagerCommunicationMechanism, "
    "adding properties specific to the CIM-XML protocol (XML "
    "encoding and CIM Operations).") ] 
class CIM_CIMXMLCommunicationMechanism : CIM_ObjectManagerCommunicationMechanism {
 
    [Override ("CommunicationMechanism"), Required]
    uint16 CommunicationMechanism = 2; 

    [Override ("Version"), Required, Description (
        "Enumeration describing the CIM-XML protocol version "
        "supported by the ObjectManager."),
        ValueMap {"1.0", "1.1", "1.2"} ]
    string Version; 

    [Deprecated {"CIM_CIMXMLCommunicationMechanism.Version"},
        Required, Description ( 
        "Enumeration describing the CIM-XML protocol version "
        "supported by the ObjectManager. It is deprecated "
        "in lieu of a more general, inherited property (Version)."),
        ValueMap {"0", "1"}, 
        Values {"Unknown", "1.0"} ] 
    uint16 CIMXMLProtocolVersion; 

    [Required, Description ( 
        "Describes whether the CIM Server is strictly validating "
        "(validates the XML document against the DTD) or not "
        "(loosely validating).") ] 
    boolean CIMValidated;
};


// ===================================================================
// MessageLog
// ===================================================================
[Version ("2.7.0"), Description (
    "MessageLog represents any type of event, error or informational "
    "register or chronicle. The object describes the existence of "
    "the log and its characteristics. Several methods are defined "
    "for retrieving, writing and deleting log entries, and "
    "maintaining the log.") ] 
class CIM_MessageLog : CIM_EnabledLogicalElement {

    [Key, MaxLen (256),
        Description (
            "CreationClassName indicates the name of the class or "
            "the subclass used in the creation of an instance. When "
            "used with the other key properties of this class, this "
            "property allows all instances of this class and its "
            "subclasses to be uniquely identified.") ]
    string CreationClassName;

    [Override ("Name"), 
        Key, MaxLen (256), 
        Description (
            "The inherited Name serves as part of the key (a unique "
            "identifier) for the MessageLog instance.") ] 
    string Name; 

    [Description (
        "An array of integers indicating the Log capabilities. "
        "Information such as \"Write Record Supported\" (value="
        "2) or \"Variable Length Records Supported\" (8) is "
        "specified in this property."),
        ArrayType ("Indexed"),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}, 
        Values {"Unknown", "Other", "Write Record Supported", 
            "Delete Record Supported", 
            "Can Move Backward in Log", "Freeze Log Supported", 
            "Clear Log Supported", 
            "Supports Addressing by Ordinal Record Number",
            "Variable Length Records Supported", 
            "Variable Formats for Records", 
            "Can Flag Records for Overwrite"}, 
        ModelCorrespondence {
            "CIM_MessageLog.CapabilitiesDescriptions"} ]
    uint16 Capabilities[];

    [Description (
        "An array of free-form strings providing more detailed "
        "explanations for any of the Log features indicated in "
        "the Capabilities array. Note, each entry of this array "
        "is related to the entry in the Capabilities array that "
        "is located at the same index."),
        ArrayType ("Indexed"),
        ModelCorrespondence {"CIM_MessageLog.Capabilities"} ]
    string CapabilitiesDescriptions[];

    [Description (
        "The maximum size, in bytes, to which the Log can grow. "
        "If there is no maximum, then MaxLogSize should be set "
        "to 0."),
        Units ("Bytes") ]
    uint64 MaxLogSize;

    [Description (
        "The size of the Log header, in bytes, if one is "
        "present. If there is no Log header, then this property "
        "should be set to 0. Headers may include general "
        "information about the Log such as the current number of "
        "records, time of last update, or a pointer to the location "
        "of the first Log entry. Note that this property is NOT the "
        "size of the header for an individual Log entry. The latter "
        "is described by the property, SizeOfRecordHeader."), 
        Units ("Bytes") ]
    uint64 SizeOfHeader;

    [Description (
        "If the SizeOfHeader property is non-zero, this property "
        "describes the structure and format of the Log header. It "
        "is a free-form string. If the SizeOfHeader property is 0, "
        "then the information in this property is undefined.") ]
    string HeaderFormat;

    [Description (
        "Maximum size, in bytes, to which an individual Log "
        "entry (record) can grow - if the Capabilities array "
        "includes a value of 7 (\"Variable Length Records "
        "Supported\"). If the Capabilities array does not "
        "include a 7, then the Log only supports fixed length "
        "entries. The size of these entries is described by "
        "this property."), 
        Units ("Bytes") ]
    uint64 MaxRecordSize;

    [Description (
        "The size of the header for the Log's individual entries, "
        "in bytes, if record headers are defined. If there are no "
        "record headers, then this property should be set to 0. "
        "Record headers may include information such as the type of "
        "the Log entry, the date/time that the entry was last "
        "updated, or a pointer to the start of optional data. Note "
        "that this property defines the header size for individual "
        "records in the Log, while the SizeOfHeader property "
        "describes the Log's overall header, typically located at "
        "the start of the MessageLog."), 
        Units ("Bytes") ]
    uint64 SizeOfRecordHeader;

    [Description (
        "If the SizeOfRecordHeader property is non-zero, this "
        "property describes the structure and format of the "
        "record headers. It is a free-form string. If the "
        "SizeOfRecordHeader property is 0, then the information "
        "in this property is undefined.") ]
    string RecordHeaderFormat;

    [Description (
        "Maximum number of records that can be captured in "
        "the Log. If undefined, a value of zero should be "
        "specified. Note that when the Capabilities array "
        "indicates that variable length records are supported "
        "(value=7), then it is possible that this maximum may "
        "not be achieved.") ]
    uint64 MaxNumberOfRecords;

    [Description (
        "Current number of entries (records) in the Log."),
        Gauge ]
    uint64 CurrentNumberOfRecords;

    [Description (
        "An enumeration describing the behavior of the Log, when "
        "it becomes full or near full. For example, the Log may "
        "wrap (value=2) or may simply stop recording entries (value"
        "=7). \n\n"
        "Some of the property's possible values need further "
        "explanation:\n"
        "3=\"Clear When Near Full\" indicates that all of the Log's "
        "entries will be deleted when a specified record capacity is "
        "reached. The capacity is specified in percentage, using the "
        "property, PercentageNearFull. 'Near Full' may be less than "
        "100% if the Log takes time to clear, and a position should "
        "always be available for new records. \n"
        "4=\"Overwrite Outdated When Needed\" describes that Log "
        "entries (timestamped later than the date/time specified in "
        "the property, TimeWhenOutdated) can be overwritten. \n"
        "5=\"Remove Outdated Records\" specifies that records "
        "(timestamped later than the date/time specified in the "
        "property, TimeWhenOutdated) are logically and/or physically "
        "removed from the Log. \n"
        "6=\"Overwrite Specific Records\" indicates that specially "
        "flagged records may be overwritten. This property only makes "
        "sense when the Capabilities array includes a value of 10, "
        "\"Can Flag Records for Overwrite\"."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"}, 
        Values {"Unknown", "Other", "Wraps When Full",
            "Clear When Near Full", 
            "Overwrite Outdated When Needed", 
            "Remove Outdated Records",
            "Overwrite Specific Records", 
            "Never Overwrite"},
        ModelCorrespondence {"CIM_MessageLog.OtherPolicyDescription", 
            "CIM_MessageLog.TimeWhenOutdated", 
            "CIM_MessageLog.PercentageNearFull"} ]
    uint16 OverwritePolicy;

    [Description (
        "When the OverwritePolicy specifies a value of 1 "
        "(\"Other\"), the Log's behavior can be explained "
        "using this property. If OverwritePolicy is not 1, "
        "then this property's contents are undefined."), 
        ModelCorrespondence {"CIM_MessageLog.OverwritePolicy"} ]
    string OtherPolicyDescription;

    [Description (
        "If the OverwritePolicy is based on 'outdated' records "
        "(values 4 or 5), this property defines when a Log entry "
        "is considered to be outdated - either by time interval or "
        "at a specific date and time."), 
        ModelCorrespondence {"CIM_MessageLog.OverwritePolicy"} ]
    datetime TimeWhenOutdated;

    [Description (
        "If the OverwritePolicy is based on clearing records "
        "when the Log is near full (value=3), this property defines "
        "the record capacity (in percentage) that is considered to "
        "be 'near full'."),
        Units ("Percent"), 
        ModelCorrespondence {"CIM_MessageLog.OverwritePolicy"} ]
    uint8 PercentageNearFull;

    [Description (
        "An enumeration describing the last change to the "
        "MessageLog."), 
        ValueMap {"0", "1", "2", "3", "4"}, 
        Values {"Unknown", "Add", "Delete", "Modify", "Log Cleared"} ]
    uint16 LastChange;

    [Description (
        "When a change is made to the Log, the date/time of "
        "that modification is captured. This property could be "
        "used to event against any update to the MessageLog.") ]
    datetime TimeOfLastChange;

    [Description (
        "When a change is made to the Log, the record number that "
        "was modified is captured.") ]
    uint64 RecordLastChanged;

    [Description (
        "Boolean indicating that the Log is currently frozen and "
        "modifications are not allowed.") ]
    boolean IsFrozen;

    [Description (
        "An enumeration describing the character set used to record "
        "data in the individual Log entries. For example, the "
        "Log records may contain ASCII data (value=2), or be raw octet "
        "strings (value=10)."), 
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
            "10", "11"}, 
        Values {"Unknown", "Other", "ASCII", "Unicode", "ISO2022", 
            "ISO8859", "Extended UNIX Code", "UTF-8", "UCS-2", 
            "Bitmapped Data", "OctetString", 
            "Defined by Individual Records"} ]
    uint16 CharacterSet; 

    [Description (
        "Requests that the MessageLog be cleared of all entries. "
        "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. If the request is not supported, "
        "check the Capabilities array that a value of 6 (\"Clear Log "
        "Supported\") is specified. \n\n"
        "Note: In a subclass, the set of possible return codes could "
        "be described 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 ClearLog();

    [Description (
        "Requests that an iteration of the MessageLog be established "
        "and that the iterator be set to the first entry in the Log. "
        "An identifier for the iterator is returned as an output "
        "parameter of the method. \n"
        "\n"
        "Regarding iteration, you have 2 choices:  1) Embed iteration "
        "data in the method call, and allow implementations to track/"
        "store this data manually; or, 2) Iterate using a separate "
        "object (for example, class ActiveIterator) as an iteration "
        "agent. The first approach is used here for interoperability. "
        "The second requires an instance of the Iterator object for "
        "EACH iteration in progress. 2's functionality could be "
        "implemented underneath 1. \n"
        "\n"
        "The return value from PositionToFirstRecord 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 PositionToFirstRecord (
        [IN ( false ), OUT, Description (
	    "An identifier for the iterator.")]
      string IterationIdentifier);

    [Description (
        "Requests that the Log's iteration identifier be advanced or "
        "retreated a specific number of records, or set to the "
        "entry at a specified numeric location. These two different "
        "behaviors are accomplished using the input parameters of the "
        "method. Advancing or retreating is achieved by setting the "
        "MoveAbsolute boolean to FALSE, and then specifying the number "
        "of entries to advance or retreat as positive or negative values "
        "in the RecordNumber parameter. Moving to a specific record "
        "number is accomplished by setting the MoveAbsolute input "
        "parameter to TRUE, and then placing the record number into "
        "the RecordNumber parameter. This can only be done if the "
        "Capabilities array includes a value of 7, \"Supports "
        "Addressing by Ordinal Record Number\". \n"
        "\n"
        "After the method completes and if ordinal record numbers are "
        "supported (the Capabilities array includes a 7), the current "
        "record number is returned in the RecordNumber output parameter. "
        "Otherwise, the value of the parameter is undefined. \n"
        "\n"
        "IterationIdentifier is defined as an Input/Output method "
        "parameter to allow the Log to embed state information in "
        "the Identifier and potentially let the identifier be "
        "maintained by the using application. \n"
        "\n"
        "The return value from PositionAtRecord should be 0 if "
        "the request was successfully executed, 1 if the request is "
        "not supported and some other value if an error occurred. If "
        "the request is not supported, check the Capabilities array "
        "regarding support for ordinal record number addressing and "
        "backward movement in the Log (values 7 and 4, respectively). \n"
        "\n"
        "Note: In a subclass, the set of possible return codes could "
        "be described 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 PositionAtRecord (
        [IN, OUT, Description (
             "An identifier for the iterator.")] 
        string IterationIdentifier, 
        [IN, Description ("Advancing or retreating the IterationIdentifier "
            "is achieved by setting the MoveAbsolute boolean to FALSE, "
            "and specifying the number of entries to advance or retreat "
            "as positive or negative values in the RecordNumber "
            "parameter. Moving to a specific record number is "
            "accomplished by setting the MoveAbsolute parameter to TRUE, "
            "and placing the record number into the RecordNumber "
            "parameter.") ] 
        boolean MoveAbsolute, 
        [IN, OUT, Description (
             "The relative or absolute record number.")] 
        sint64 RecordNumber);

      [Description (
          "Requests that the record indicated by the "
          "IterationIdentifier be retrieved from the MessageLog.  "
          "After retrieval, the IterationIdentifier may be advanced to "
          "the next record by setting the PositionToNext input "
          "parameter to TRUE.  Two output parameters are defined for "
          "the method - RecordData which holds the contents of the Log "
          "entry (as an array of bytes that can be recast to an "
          "appropriate format), and RecordNumber which returns the "
          "current record number addressed via the Iteration "
          "Identifier.  The RecordNumber parameter is only "
          "defined/valid when the Capabilities array indicates that "
          "ordinal record number addressing is supported (a value of "
          "7).  \n"
          "\n"
          "IterationIdentifier is defined as an Input/Output method "
          "parameter to allow the Log to embed state information in "
          "the Identifier and potentially let the identifier be "
          "maintained by the using application.  \n"
          "\n"
          "The return value from GetRecord 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 GetRecord ( 
         [IN, OUT, Description (
             "An identifier for the iterator.")]
      string IterationIdentifier, 
         [IN, Description (
             "Boolean indicating that the Iteration Identifier should "
             "be advanced to the next record, after retrieving the "
             "current Log entry.")]
      boolean PositionToNext, 
         [IN ( false ), OUT, Description (
             "The record number.")]
      uint64 RecordNumber, 
         [IN ( false ), OUT, Description (
             "The record data.")]
      uint8 RecordData[]);  

      [Description (
          "Requests that the record indicated by the "
          "IterationIdentifier be deleted from the MessageLog.  After "
          "deletion, the Iteration Identifier may be advanced to the "
          "next record by setting the PositionToNext input parameter "
          "to TRUE.  If set to FALSE, then the IterationIdentifier "
          "will be positioned at the previous record.  Two output "
          "parameters are defined for the method - RecordData which "
          "holds the contents of the deleted Log entry (as an array of "
          "bytes that can be recast to an appropriate format or "
          "discarded), and RecordNumber which returns the current "
          "record number addressed via the IterationIdentifier.  The "
          "RecordNumber parameter is only defined/valid when the "
          "Capabilities array indicates that ordinal record number "
          "addressing is supported (a value of 7).  \n"
          "\n"
          "IterationIdentifier is defined as an Input/Output method "
          "parameter to allow the Log to embed state information in "
          "the Identifier and potentially let the identifier be "
          "maintained by the using application.  \n"
          "\n"
          "The return value from DeleteRecord should be 0 if the "
          "request was successfully executed, 1 if the request is not "
          "supported, and some other value if an error occurred.  If "
          "the request is not supported, check the Capabilities array "
          "that a value of 3 (\"Delete Record Supported\") is "
          "specified.  \n"
          "\n"
          "Note: In a subclass, the set of possible return codes could "
          "be described 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 DeleteRecord ( 
         [IN, OUT, Description (
             "An identifier for the iterator.")]
      string IterationIdentifier, 
         [IN, Description (
             "Boolean that when set to TRUE requests the "
             "IterationIdentifier to be advanced to the next record, "
             "after the current entry is deleted.  If set to FALSE, "
             "IterationIdentifier is set to the previous record.")]
      boolean PositionToNext, 
         [IN ( false ), OUT, Description (
             "The record number.")]
      uint64 RecordNumber, 
         [IN ( false ), OUT, Description (
             "The record data.")]
      uint8 RecordData[]); 

      [Description (
          "Requests that a record be inserted at the Log position "
          "indicated by the IterationIdentifier.  The entry's data is "
          "provided in the RecordData input parameter.  After "
          "insertion, the IterationIdentifier may be advanced to the "
          "next record by setting the PositionToNext input parameter "
          "to TRUE.  The output parameter, RecordNumber, returns the "
          "current record number addressed via the "
          "IterationIdentifier.  This parameter is only defined/valid "
          "when the Capabilities array indicates that ordinal record "
          "number addressing is supported (a value of 7).  \n"
          "\n"
          "IterationIdentifier is defined as an Input/Output method "
          "parameter to allow the Log to embed state information in "
          "the Identifier and potentially let the identifier be "
          "maintained by the using application.  \n"
          "\n"
          "The return value from WriteRecord should be 0 if the "
          "request was successfully executed, 1 if the request is not "
          "supported, and some other value if an error occurred.  If "
          "the request is not supported, check the Capabilities array "
          "that a value of 2 (\"Write Record Supported\") is "
          "specified.  \n"
          "\n"
          "Note: In a subclass, the set of possible return codes could "
          "be described 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 WriteRecord ( 
         [IN, OUT, Description (
             "An identifier for the iterator.")]
      string IterationIdentifier, 
         [IN, Description (
             "Boolean indicating that the Iteration Identifier should "
             "be advanced to the next record, after writing the Log "
             "entry.")]
      boolean PositionToNext, 
         [IN, Description (
             "The record data.")]
      uint8 RecordData[], 
         [IN ( false ), OUT, Description (
             "The record number.")]
      uint64 RecordNumber); 

      [Description (
          "Requests that an iteration of the Log, identified by the "
          "IterationIdentifier input parameter, be stopped.  The "
          "return value from CancelIteration 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 CancelIteration ( 
         [IN, Description (
             "An identifier for the iterator.")]
      string IterationIdentifier); 

      [Description (
          "Requests that the MessageLog be placed in a frozen state "
          "(\"Freeze\" input parameter = TRUE) or 'unfrozen' (= "
          "FALSE).  If frozen, modifications to the Log will not be "
          "allowed.  If successful, the Log's IsFrozen boolean "
          "property will be updated to reflect the desired state.  \n"
          "\n"
          "The method's 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.  If the request "
          "is not supported, check the Capabilities array that a value "
          "of 5 (\"Freeze Log Supported\") is specified.  \n"
          "\n"
          "Note: In a subclass, the set of possible return codes could "
          "be described 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 FreezeLog( 
         [IN, Description (
             "If TRUE then freeze the log, if FALSE 'unfreeze' the "
             "log.")]
      boolean Freeze); 

      [Description (
          "Requests that the record indicated by the "
          "IterationIdentifier be flagged as overwriteable.  This "
          "method is only supported when the Capabilities array "
          "includes a value of 10, \"Can Flag Records for "
          "Overwrite\".  After updating the entry, the "
          "IterationIdentifier may be advanced to the next record by "
          "setting the PositionToNext input parameter to TRUE.  One "
          "output parameter is defined for the method RecordNumber.  "
          "It returns the current record number addressed via the "
          "Iteration Identifier.  This parameter is only defined/valid "
          "when the Capabilities array indicates that ordinal record "
          "number addressing is supported (a value of 7).  \n"
          "\n"
          "IterationIdentifier is defined as an Input/Output method "
          "parameter to allow the Log to embed state information in "
          "the Identifier and potentially let the identifier be "
          "maintained by the using application.  \n"
          "\n"
          "The return value from FlagRecordForOverwrite 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 FlagRecordForOverwrite ( 
         [IN, OUT, Description (
             "An identifier for the iterator.")]
      string IterationIdentifier, 
         [IN, Description (
             "Boolean indicating that the Iteration Identifier should "
             "be advanced to the next record, after updating the "
             "current Log entry.")]
      boolean PositionToNext, 
         [IN ( false ), OUT, Description (
             "The record number.")]
      uint64 RecordNumber); 
};


// ===================================================================
// Account
// ===================================================================
   [Version ( "2.8.0"), Description (
       "CIM_Account is the information held by a SecurityService to "
       "track identity and privileges managed by that service.  Common "
       "examples of an Account are the entries in a UNIX /etc/passwd "
       "file.  Several kinds of security services use various "
       "information from those entries - the /bin/login program uses "
       "the account name ('root') and hashed password to authenticate "
       "users, and the file service, for instance, uses the UserID "
       "field ('0') and GroupID field ('0') to record ownership and "
       "determine access control privileges on files in the file "
       "system.  This class is defined so as to incorporate "
       "commonly-used LDAP attributes to permit implementations to "
       "easily derive this information from LDAP-accessible "
       "directories.  \n"
       "\n"
       "The semantics of Account overlap with that of the class, "
       "CIM_Identity.  However, aspects of Account - such as its "
       "specific tie to a System - are valuable and have been widely "
       "implemented.  For this reason, the Account and Identity "
       "classes are associated using a subclass of LogicalIdentity "
       "(AccountIdentity), instead of deprecating the Account class in "
       "the CIM Schema.  When an Account has been authenticated, the "
       "corresponding Identity's TrustEstablished Boolean would be set "
       "to TRUE.  Then, the Identity class can be used as defined for "
       "authorization purposes.") ]
class CIM_Account : CIM_LogicalElement {

      [Key, Propagated ( "CIM_System.CreationClassName"), Description (
          "The scoping System's CCN."), 
       MaxLen ( 256) ]
   string SystemCreationClassName;

      [Key, Propagated ( "CIM_System.Name"), Description (
          "The scoping System's Name."), 
       MaxLen ( 256) ]
   string SystemName;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance.  When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256) ]
   string CreationClassName;

      [Key, Override ( "Name"), Description (
          "The Name property defines the label by which the object is "
          "known.  The value of this property may be set to be the "
          "same as that of the UserID property or, in the case of an "
          "LDAP-derived instance, the Name property value may be set "
          "to the distinguishedName of the LDAP-accessed object "
          "instance."), 
       MaxLen ( 1024) ]
   string Name;

      [Description (
          "UserID is the value used by the SecurityService to "
          "represent identity.  For an authentication service, the "
          "UserID may be the name of the user, or for an authorization "
          "service the value which serves as a handle to a mapping of "
          "the identity."), 
       MaxLen ( 256) ] 
   string UserID;

   [Description (  
      "In the case of an LDAP-derived instance, the ObjectClass "
      "property value(s) may be set to the objectClass attribute "
      "values.") ]
   string ObjectClass[];

      [Description (
          "The Descriptions property values may contain human-readable "
          "descriptions of the object.  In the case of an LDAP-derived "
          "instance, the description attribute may have multiple "
          "values that, therefore, cannot be placed in the inherited "
          "Description property."), 
       MaxLen ( 1024) ]
   string Descriptions[];

      [Description (
          "Based on RFC1274, the host name of the system(s) for which "
          "the account applies.  The host name may be a "
          "fully-qualified DNS name or it may be an unqualified host "
          "name.") ] 
   string Host[];

   [Description (  
      "This property contains the name of a locality, such as a "
      "city, county or other geographic region.") ]
   string LocalityName[];

   [Required, Description (  
      "The name of the organization related to the account.") ]
   string OrganizationName[];

   [Description (  
      "The name of an organizational unit related to the account.") ]
   string OU[];

   [Description (  
      "In the case of an LDAP-derived instance, the See Also "
      "property specifies distinguishedName of other Directory "
      "objects which may be other aspects (in some sense) of the "
      "same real world object.") ]
   string SeeAlso[];

      [Description (
          "Based on inetOrgPerson and for directory compatibility, the "
          "UserCertificate property may be used to specify a public "
          "key certificate for the person."), 
       OctetString ]
   string UserCertificate[];

      [Description (
          "In the case of an LDAP-derived instance, the UserPassword "
          "property may contain an encrypted password used to access "
          "the person's resources in a directory."), 
       OctetString ]
   string UserPassword[];
};


// ===================================================================
// StoragePool
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A pool of Storage that is managed within the scope of a "
       "particular System.  StoragePools may consist of component "
       "StoragePools or StorageExtents.  StorageExtents that belong to "
       "the StoragePool have a Component relationship to the "
       "StoragePool.  StorageExtents/StoragePools that are elements of "
       "a pool have their available space aggregated into the pool.  "
       "StoragePools and StorageVolumes may be created from "
       "StoragePools.  This is indicated by the "
       "AllocatedFromStoragePool association.  StoragePool is scoped "
       "to a system by the HostedStoragePool association.")] 
class CIM_StoragePool : CIM_LogicalElement {
    
      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nForDMTFdefined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]        
    string InstanceID;
 
      [Required, Description (
          "A unique name in the context of the System that identifies "
          "this pool."), 
       MaxLen ( 256 )]
    string PoolID;
 
      [Description (
          "If true, \"Primordial\" indicates that the containing "
          "System does not have the ability to create or delete this "
          "operational element.  This is important because "
          "higher-level StoragePools may be assembled using the "
          "Component or AllocatedFromStoragePool associations.  "
          "Although the higher-level abstractions can be created and "
          "deleted, the most basic, (i.e.  primordial), hardware-based "
          "StoragePools cannot.  They are physically realized as part "
          "of the System, or are actually managed by some other System "
          "and imported as if they were physically realized.")]
   boolean Primordial = false;

      [Description (
          "The total amount of raw storage (in bytes) managed by this "
          "StoragePool.  This includes all of the bytes consumed to "
          "create the storage surfaced by this StoragePool, including "
          "all of the overhead bytes that are not reflected in the "
          "size of the logical storage allocated from this "
          "StoragePool.  \n"
          "Conceptually TotalManagedSpace reflects all storage known "
          "via Component associations to underlying StorageExtents or "
          "via AllocatedFromStoragePool associations to underlying "
          "StoragePools.  However, note that this underlying storage "
          "may not be surfaced by the instrumentation."), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.RemainingManagedSpace" }]    
   uint64 TotalManagedSpace;

      [Required, Description (
          "The remaining amount of raw storage (in bytes) from the "
          "TotalManagedSpace of this StoragePool.  This property is "
          "maintained here to provide efficient access to this "
          "information.  However, note that it is possible to compute "
          "RemainingManagedSpace as (TotalManagedSpace minus the sum "
          "of SpaceConsumed from all of the AllocatedFromStoragePool "
          "references from this StoragePool).  Note that SpaceConsumed "
          "remains useful to determine the amount of raw storage "
          "consumed by a particular allocated element."), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace",
          "CIM_AllocatedFromStoragePool.SpaceConsumed" }]
    uint64 RemainingManagedSpace;

      [Description (
          "For pools that support discrete sizes for volume or pool "
          "creation, this method can be used to retrieve a list of "
          "supported sizes.  Note that different pool implementations "
          "may support either or both the GetSupportedSizes and "
          "GetSupportedSizeRanges methods at different times, "
          "depending on Pool configuration.  Also note that the "
          "advertised sizes may change after the call due to requests "
          "from other clients.  If the pool currently only supports a "
          "range of sizes, then the return value will be set to 1."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Method completed OK", "Method not supported",
          "Use GetSupportedSizeRange instead" }]
    uint32 GetSupportedSizes (
    [IN, Description(
            "The type of element for which supported sizes are "
            "reported for."),
            ValueMap{"2", "3"},
            Values {"Storage Pool", "Storage Volume"}]
        uint16 ElementType,
        [IN, Description (
            "The StorageSetting for which supported sizes should be "
            "reported for.")]
        CIM_StorageSetting REF Goal,
        [OUT, IN(false), Description (
            "List of support sizes for a Volume/Pool creation or "
            "modification."),
            Units ("Bytes") ]
        uint64  Sizes[] );

      [Description (
          "For pools that that support a range of sizes for volume or "
          "pool creation, this method can be used to retrieve the "
          "supported range.  Note that different pool implementations "
          "may support either or both the GetSupportedSizes and "
          "GetSupportedSizeRanges methods at different times, "
          "depending on Pool configuration.  Also note that the "
          "advertised sizes may change after the call due to requests "
          "from other clients.  If the pool currently only supports "
          "discrete sizes, then the return value will be set to 1."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Method completed OK", "Method not supported",
          "Use GetSupportedSizes instead" }]
    uint32 GetSupportedSizeRange (
         [IN, Description (
             "The type of element for which supported size ranges are "
             "reported for."), 
          ValueMap { "2", "3" }, 
          Values { "Storage Pool", "Storage Volume" }]
      uint16 ElementType, 
         [IN, Description (
             "The StorageSetting for which supported size ranges "
             "should be reported for.")]
      CIM_StorageSetting REF Goal, 
         [IN ( false ), OUT, Description (
             "The minimum size for a volume/pool in bytes."), 
          Units ( "Bytes" )]
      uint64 MinimumVolumeSize, 
         [IN ( false ), OUT, Description (
             "The maximum size for a volume/pool in bytes."), 
          Units ( "Bytes" )]
      uint64 MaximumVolumeSize, 
         [IN ( false ), OUT, Description (
             "A volume/pool size must be a multiple of this value "
             "which is specified in bytes."), 
          Units ( "Bytes" )]
      uint64 VolumeSizeDivisor); 
};


// ===================================================================
// RedundancyGroup
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A class derived from LogicalElement that is a special "
       "collection of ManagedSystemElements.  This collection "
       "indicates that the aggregated components together provide "
       "redundancy.  All elements aggregated in a RedundancyGroup "
       "should be instantiations of the same object class.")]
class CIM_RedundancyGroup : CIM_LogicalElement {

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance.  When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
    string CreationClassName;

      [Key, Override ( "Name" ), Description (
          "The RedundancyGroup Name serves as the key for the Group's "
          "instance in an enterprise environment."), 
       MaxLen ( 256 )]
    string Name;

      [Description (
          "RedundancyStatus provides information on the state of the "
          "RedundancyGroup.  \"Fully Redundant\" (value=2) means that "
          "all of the configured redundancy is still available; "
          "\"Degraded Redundancy\" (3) means that some failures have "
          "been experienced but some reduced amount of redundancy is "
          "still available; \"Redundancy Lost\" (4) means that a "
          "sufficient number of failures have been experienced such "
          "that no redundancy is available and the next failure "
          "experienced will cause overall failure.  Also, the values, "
          "\"Other\" (1) and \"Unknown\" (0), are defined."), 
       ValueMap { "0", "1", "2", "3", "4" }, 
       Values { "Unknown", "Other", "Fully Redundant",
          "Degraded Redundancy", "Redundancy Lost" }]
   uint16 RedundancyStatus;
};


// ===================================================================
// Job
// ===================================================================
   [Abstract, Version ( "2.8.0" ), Description (
       "A Job is a LogicalElement representing an executing unit of "
       "work, such as a script or a print job.  A Job is distinct from "
       "a Process in that a Job can be scheduled, queued, and its "
       "execution is not limited to a single system.")]
class CIM_Job : CIM_LogicalElement {
      
    [Description (
        "A free form string representing the Job's status.  "
        "The primary status is reflected in the inherited "
        "OperationalStatus property. JobStatus provides additional, "
        "implementation-specific details."),
        ModelCorrespondence {
            "ManagedSystemElement.OperationalStatus"} ]
    string JobStatus;
   
    [Description (
        "The time that the Job was submitted to execute. A value of all "
        "zeroes indicates that the owning element is not capable of "
        "reporting a date and time.  Therefore, the ScheduledStartTime "
        "and StartTime are reported as intervals relative to the time "
        "their values are requested.") ]
    datetime TimeSubmitted;
      
    [Deprecated {"CIM_Job.RunMonth", "CIM_Job.RunDay",
            "CIM_Job.RunDayOfWeek", "CIM_Job.RunStartInterval"}, 
        Write, Description (
        "The time that the current Job is scheduled to start. This may "
        "be represented by the actual date and time, or an interval "
        "relative to the time that this property is requested. A value "
        "of all zeroes indicates that the Job is already executing. The "
        "property is deprecated in lieu of the more expressive "
        "scheduling properties, RunMonth, RunDay, RunDayOfWeek and "
        "RunStartInterval.") ]
    datetime ScheduledStartTime;
   
    [Description (
        "The time that the Job was actually started.  This "
        "may be represented by an actual date and time, or by an "
        "interval relative to the time that this property is "
        "requested. Note that this property is also present in the "
        "JobProcessingStatistics class. This is necessary to capture "
        "the processing information for recurring Jobs, since only "
        "the 'last' run time can be stored in this single-valued "
        "property.") ]
    datetime StartTime;
      
    [Description (
        "The time interval that the Job has been executing or the "
        "total execution time if the Job is complete. Note that "
        "this property is also present in the JobProcessingStatistics "
        "class. This is necessary to capture the processing "
        "information for recurring Jobs, since only the 'last' "
        "run time can be stored in this single-valued property.") ]
    datetime ElapsedTime;
 
      [Write, Description (
          "Number of times that the Job should be run.  A value of 1 "
          "indicates that the Job is NOT recurring, while any non-zero "
          "value indicates a limit to the number of times that the Job "
          "will recur.  Zero indicates that there is no limit to the "
          "number of times that the Job can be processed, but that it "
          "is terminated either AFTER the UntilTime, or by manual "
          "intervention.  By default, a Job is processed once.")]
    uint32 JobRunTimes = 1;
 
      [Write, Description (
          "The month during which the Job should be processed.  "
          "Specify 0 for January, 1 for February, and so on."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "January", "February", "March", "April", "May", "June",
          "July", "August", "September", "October", "November",
          "December" }, 
       ModelCorrespondence { "CIM_Job.RunDay", "CIM_Job.RunDayOfWeek",
          "CIM_Job.RunStartInterval" }]
    uint8 RunMonth;
    
      [Write, Description (
          "The day in the month on which the Job should be processed.  "
          "There are two different interpretations for this property, "
          "depending on the value of DayOfWeek.  In one case, RunDay "
          "defines the day-in-month on which the Job is processed.  "
          "This interpretation is used when the DayOfWeek is 0.  A "
          "positive or negative integer indicates whether the RunDay "
          "should be calculated from the beginning or the end of the "
          "month.  For example, 5 indicates the fifth day in RunMonth "
          "and -1 indicates the last day in the RunMonth.  \n"
          "\n"
          "When RunDayOfWeek is not 0, RunDay is the day-in-month on "
          "which the Job is processed, defined in conjunction with "
          "RunDayOfWeek.  For example, if RunDay is 15 and "
          "RunDayOfWeek is Saturday, then the Job is processed on the "
          "first Saturday on or AFTER the 15th day in the RunMonth "
          "(e.g., the third Saturday in the month).  If RunDay is 20 "
          "and RunDayOfWeek is -Saturday, then this indicates the "
          "first Saturday on or BEFORE the 20th day in the RunMonth.  "
          "If RunDay is -1 and RunDayOfWeek is -Sunday, then this "
          "indicates the last Sunday in the RunMonth."), 
       MinValue ( -31 ), MaxValue ( 31 ), 
       ModelCorrespondence { "CIM_Job.RunMonth",
          "CIM_Job.RunDayOfWeek", "CIM_Job.RunStartInterval" }]
   sint8 RunDay;
     
      [Write, Description (
          "Positive or negative integer used in conjunction with "
          "RunDay to indicate the day of the week on which the Job is "
          "processed.  RunDayOfWeek is set to 0 to indicate an exact "
          "day of the month, such as March 1.  A positive integer "
          "(representing Sunday, Monday, ..., Saturday) means that the "
          "day of week is found on or AFTER the specified RunDay.  A "
          "negative integer (representing -Sunday, -Monday, ..., "
          "-Saturday) means that the day of week is found on or BEFORE "
          "the RunDay."), 
       ValueMap { "-7", "-6", "-5", "-4", "-3", "-2", "-1", "0", "1",
          "2", "3", "4", "5", "6", "7" }, 
       Values { "-Saturday", "-Friday", "-Thursday", "-Wednesday",
          "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
          "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
          "Friday", "Saturday" }, 
       ModelCorrespondence { "CIM_Job.RunMonth", "CIM_Job.RunDay",
          "CIM_Job.RunStartInterval" }]
   sint8 RunDayOfWeek;
    
      [Write, Description (
          "The time interval after midnight when the Job should be "
          "processed.  For example, \n"
          "00000000020000.000000:000 \n"
          "indicates that the Job should be run on or after two "
          "o'clock, local time or UTC time (distinguished using the "
          "LocalOrUtcTime property."), 
       ModelCorrespondence { "CIM_Job.RunMonth", "CIM_Job.RunDay",
          "CIM_Job.RunDayOfWeek", "CIM_Job.RunStartInterval" }]
   datetime RunStartInterval;
 
      [Write, Description (
          "This property indicates whether the times represented in "
          "the RunStartInterval and UntilTime properties represent "
          "local times or UTC times.  Time values are synchronized "
          "worldwide by using the enumeration value 2, \"UTC Time\"."), 
       ValueMap { "1", "2" }, 
       Values { "Local Time", "UTC Time" }]
   uint16 LocalOrUtcTime;
 
      [Write, Description (
          "The time after which the Job is invalid or should be "
          "stopped.  This may be represented by an actual date and "
          "time, or by an interval relative to the time that this "
          "property is requested.  A value of all nines indicates that "
          "the Job can run indefinitely."), 
       ModelCorrespondence { "CIM_Job.LocalOrUtcTime" }]
   datetime UntilTime;

      [Write, Description (
          "User to be notified upon the Job completion or failure.")]
   string Notify;

      [Description (
          "The User that submitted the Job or the Service/method "
          "name/etc.  that caused the job to be created."), 
       ModelCorrespondence { "CIM_OwningJobElement" }]
   string Owner;
      
      [Write, Description (
          "Indicates the urgency or importance of execution of the "
          "Job.  The lower the number, the higher the priority.  Note "
          "that this property is also present in the "
          "JobProcessingStatistics class.  This is necessary to "
          "capture the setting information that would influence a "
          "Job's results.")]
   uint32 Priority;

      [Description (
          "The percentage of the job that has completed at the time "
          "that this value is requested.  Note that this property is "
          "also present in the JobProcessingStatistics class.  This is "
          "necessary to capture the processing information for "
          "recurring Jobs, since only the 'last' run data can be "
          "stored in this single-valued property."), 
       Units ( "Percent" ), MinValue ( 0 ), MaxValue ( 101 )]
   uint16 PercentComplete;
    
      [Write, Description (
          "Indicates whether or not the job should be automatically "
          "deleted upon completion.  Note that the 'completion' of a "
          "recurring job is defined by its JobRunTimes or UntilTime "
          "properties, OR when the Job is terminated by manual "
          "intervention.  If this property is set to false and the job "
          "completes, then the extrinsic method DeleteInstance MUST be "
          "used to delete the job versus updating this property.")]
   boolean DeleteOnCompletion;

      [Description (
          "A vendor specific error code.  This MUST be set to zero if "
          "the Job completed without error.  Note that this property "
          "is also present in the JobProcessingStatistics class.  This "
          "is necessary to capture the processing information for "
          "recurring Jobs, since only the 'last' run error can be "
          "stored in this single-valued property."), 
       ModelCorrespondence { "CIM_Job.ErrorDescription" }]
   uint16 ErrorCode;
 
      [Description (
          "A free form string containing the vendor error "
          "description.  Note that this property is also present in "
          "the JobProcessingStatistics class.  This is necessary to "
          "capture the processing information for recurring Jobs, "
          "since only the 'last' run error can be stored in this "
          "single-valued property."), 
       ModelCorrespondence { "CIM_Job.ErrorCode" }]
   string ErrorDescription;
    
      [Deprecated { "CIM_ConcreteJob.RequestStateChange()" }, 
       Description (
          "KillJob is being deprecated because there is no distiction "
          "made between an orderly shutdown and an immediate kill.  "
          "CIM_ConcreteJob.RequestStateChange() provides 'Terminate' "
          "and 'Kill' options to allow this distinction.  \n"
          "A method to kill this job and any underlying processes, and "
          "to remove any 'dangling' associations."), 
       ValueMap { "0", "1", "2", "3", "4", "6", "7", "..",
          "32768..65535" }, 
       Values { "Success", "Not Supported", "Unknown", "Timeout",
          "Failed", "Access Denied", "Not Found", "DMTF Reserved",
          "Vendor Specific" }]
   uint32 KillJob( 
         [IN, Description (
             "Indicates whether or not the Job should be automatically "
             "deleted upon termination.  This parameter takes "
             "precedence over the property, DeleteOnCompletion.")]
      boolean DeleteOnKill);
        
      [Description (
          "Describes the recovery action to be taken for an "
          "unsuccessfully run Job.  The possible values are: \n"
          "0 = \"Unknown\", meaning it is unknown as to what recovery "
          "action to take \n"
          "1 = \"Other\", indicating that the recovery action will be "
          "specified in the property, OtherRecoveryAction \n"
          "2 = \"Do Not Continue\", meaning stop the execution of the "
          "job and appropriately update its status \n"
          "3 = \"Continue With Next Job\", meaning continue with the "
          "next job in the queue \n"
          "4 = \"Re-run Job\", indicating that the job should be "
          "re-run \n"
          "5 = \"Run Recovery Job\", meaning run the Job associated "
          "using the RecoveryJob relationship.  Note that the recovery "
          "Job MUST already be on the queue from which it will run."), 
       ValueMap { "0", "1", "2", "3", "4", "5" }, 
       Values { "Unknown", "Other", "Do Not Continue",
          "Continue With Next Job", "Re-run Job", "Run Recovery Job" }, 
       ModelCorrespondence { "CIM_Job.OtherRecoveryAction" }]
   uint16 RecoveryAction;

      [Description (
          "A string describing the recovery action when the instance's "
          "RecoveryAction property is 1 (\"Other\")."), 
       ModelCorrespondence { "CIM_Job.RecoveryAction" }]
   string OtherRecoveryAction;
};


// ===================================================================
// ConcreteJob
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A concrete version of Job.  This class represents a generic "
       "and instantiable unit of work, such as a batch or a print "
       "job.")]
class CIM_ConcreteJob : CIM_Job {

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nForDMTFdefined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]
   string InstanceID;

      [Required, Override ( "Name" ), Description (
          "The user friendly name for this instance of Job.  In "
          "addition, the user friendly name can be used as a property "
          "for a search or query.  (Note: Name does not have to be "
          "unique within a namespace.)")]
   string Name;

      [Description (
          "JobState is an integer enumeration that indicates the "
          "operational state of a Job.  It can also indicate "
          "transitions between these states, for example, 'Shutting "
          "Down' and 'Starting'.  Following is a brief description of "
          "the states: \n"
          "New (2) indicates that the job has never been started.  \n"
          "Starting (3) indicates that the job is moving from the "
          "'New', 'Suspended', or 'Service' states into the 'Running' "
          "state.  \n"
          "Running (4) indicates that the Job is running.  \n"
          "Suspended (5) indicates that the Job is stopped, but may be "
          "restarted in a seamless manner.  \n"
          "Shutting Down (6) indicates the job is moving to a "
          "'Completed', 'Terminated', or 'Killed' state.  \n"
          "Completed (7) indicates that the job has completed "
          "normally.  \n"
          "Terminated (8) indicates that the job has been stopped by a "
          "'Terminate' state change request.  The job and all its "
          "underlying processes are ended and may be restarted (this "
          "is job-specific) only as a new job.  \n"
          "Killed (9) indicates that the job has been stopped by a "
          "'Kill' state change request.  Underlying processes may have "
          "been left running and cleanup may be required to free up "
          "resources.  \n"
          "Exception (10) indicates that the Job is in an abnormal "
          "state that may be indicative of an error condition.  Actual "
          "status may be surfaced though job-specific objects.  \n"
          "Service (11) indicates that the Job is in a vendor-specific "
          "state that supports problem discovery and/or resolution."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
          "12..32767", "32768..65535" }, 
       Values { "New", "Starting", "Running", "Suspended",
          "Shutting Down", "Completed", "Terminated", "Killed",
          "Exception", "Service", "DMTF Reserved", "Vendor Reserved" }]
   uint16 JobState;

      [Description (
          "The date/time when the Job's State last changed.  If the "
          "state of the Job has not changed and this property is "
          "populated, then it MUST be set to a 0 interval value.  If a "
          "state change was requested, but rejected or not yet "
          "processed, the property MUST NOT be updated.")]
   datetime TimeOfLastStateChange;

      [Description (
          "Requests that the job's state be changed to the value "
          "specified in the RequestedState parameter.  Invoking the "
          "RequestStateChange method multiple times could result in "
          "earlier requests being overwritten/lost.  \n"
          "If 0 is returned, then the task completed successfully.  "
          "Any other return code indicates an error condition."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
          "4097", "4098", "4099", "4100..32767", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported",
          "Unknown/Unspecified Error",
          "Can NOT complete within Timeout Period", "Failed",
          "Invalid Parameter", "In Use", "DMTF Reserved",
          "Method Parameters Checked - Transition Started",
          "Invalid State Transition",
          "Use of Timeout Parameter Not Supported", "Busy",
          "Method Reserved", "Vendor Specific" }]
   uint32 RequestStateChange( 
         [IN, Description (
             "Changes the state of a job.  \n"
             "Start (2) changes the state to 'Running'.  \n"
             "Suspend (3) stops the job temporarily.  The intention is "
             "to subsequently restart the job with 'Start'.  It may be "
             "possible to enter the 'Service' state while suspended - "
             "this is job-specific.  \n"
             "Terminate (4) stops the job cleanly, saving data, "
             "preserving state, and shutting down all underlying "
             "processes in an orderly manner.  \n"
             "Kill (5) terminates the job immediately with no "
             "requirement to save data or preserve state.  Service (6) "
             "puts the job into a vendor-specific service state.  The "
             "job may be able to be restarted."), 
          ValueMap { "2", "3", "4", "5", "6", "7..32767",
             "32768..65535" }, 
          Values { "Start", "Suspend", "Terminate", "Kill", "Service",
             "DMTF Reserved", "Vendor Reserved" }]
      uint16 RequestedState, 
         [IN, Description (
             "A timeout period that specifies the maximum amount of "
             "time that the client expects the transition to the new "
             "state to take.  The interval format MUST be used to "
             "specify the TimeoutPeriod.  A value of 0 or a null "
             "parameter indicates that the client has no time "
             "requirements for the transition.  \n"
             "If this property does not contain 0 or null and the "
             "implementation doesn't support this parameter.  A return "
             "code of 'Use Of Timeout Parameter Not Supported' MUST be "
             "returned.")]
      datetime TimeoutPeriod); 
};


// ===================================================================
// PhysicalElement
// ===================================================================
   [Abstract, Version ( "2.8.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, 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."), 
       MaxLen ( 256 )]
    string Tag;
    
      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance.  When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
    string CreationClassName;
    
    [Override ("ElementName"),
        MappingStrings {"MIB.IETF|Entity-MIB.entPhysicalName"} ]
    string ElementName;
    
      [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."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalMfgName" }] 
    string Manufacturer;
    
      [Description (
          "The name by which the PhysicalElement is generally known."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalDescr" }]
   string Model;

      [Description (
          "The stock keeping unit number for this PhysicalElement."), 
       MaxLen ( 64 )]
   string SKU;
    
      [Description (
          "A manufacturer-allocated number used to identify the "
          "Physical Element."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalSerialNum" }]
   string SerialNumber;

      [Description (
          "A string indicating the version of the PhysicalElement."), 
       MaxLen ( 64 ), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalHardwareRev" }]
   string Version;

      [Description (
          "The part number assigned by the organization responsible "
          "for producing or manufacturing the PhysicalElement."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalModelName" }]
   string PartNumber;
    
      [Write, 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."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalAlias" }]
   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;
      
      [Description (
          "A vendor-specific hardware type for the PhysicalElement.  "
          "It describes the specific equipment type for the element, "
          "as defined by the vendor/manufacturer."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalVendorType" }]
   string VendorEquipmentType;

      [Write, Description (
          "User-assigned and writeable asset tracking identifier for "
          "the PhysicalElement."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalAssetID" }]
   string UserTracking;

      [Description (
          "Boolean indicating whether this PhysicalElement can be "
          "FRUed (TRUE) or not (FALSE)."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalIsFRU" }]
   boolean CanBeFRUed;
};


// ===================================================================
// PhysicalPackage
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The PhysicalPackage class represents PhysicalElements that "
       "contain or host other components.  Examples are a Rack "
       "enclosure or an adapter Card.")]
class CIM_PhysicalPackage : CIM_PhysicalElement {
    
      [Description (
          "The RemovalCapabilites property is used to describe the "
          "conditions under which a PhysicalPackage can be removed.  "
          "Since all PhysicalPackages are not removable, this property "
          "defaults to 2, 'Not Applicable'."), 
       ValueMap { "0", "2", "3", "4" }, 
       Values { "Unknown", "Not Applicable", "Removable when off",
          "Removable when on or off" }]
    uint16 RemovalConditions = 2;

      [Deprecated { "CIM_PhysicalPackage.RemovalConditions" }, 
       Description (
          "The use of this property is being deprecated.  Instead "
          "RemovalConditions should be used.  The RemovalConditions "
          "property addresses whether a PhysicalPackage is removable "
          "with or without power being applied.  \n"
          "A PhysicalPackage is Removable if it is designed to be "
          "taken in and out of the physical container in which it is "
          "normally found, without impairing the function of the "
          "overall packaging.  A Package can still be Removable if "
          "power must be 'off' in order to perform the removal.  If "
          "power can be 'on' and the Package removed, then the Element "
          "is both Removable and HotSwappable.  For example, an extra "
          "battery in a laptop is Removable, as is a disk drive "
          "Package inserted using SCA connectors.  However, the latter "
          "is also HotSwappable.  A laptop's display is not Removable, "
          "nor is a non-redundant power supply.  Removing these "
          "components would impact the function of the overall "
          "packaging or is impossible due to the tight integration of "
          "the Package.")]
    boolean Removable;
    
      [Deprecated { "No Value" }, Description (
          "The use of this property is being deprecated because it is "
          "redundant with the FRU class and its associations.  A "
          "PhysicalPackage is Replaceable if it is possible to replace "
          "(FRU or upgrade) the Element with a physically different "
          "one.  For example, some ComputerSystems allow the main "
          "Processor chip to be upgraded to one of a higher clock "
          "rating.  In this case, the Processor is said to be "
          "Replaceable.  Another example is a power supply Package "
          "mounted on sliding rails.  All Removable packages are "
          "inherently Replaceable.")]
   boolean Replaceable;
    
      [Deprecated { "CIM_PhysicalPackage.RemovalConditions" }, 
       Description (
          "The use of this property is being deprecated.  Instead "
          "RemovalConditions should be used.  The RemovalConditions "
          "property addresses whether a PhysicalPackage is removable "
          "with or without power being applied.  \n"
          "\n"
          "A PhysicalPackage is HotSwappable if it is possible to "
          "replace the Element with a physically different but "
          "equivalent one while the containing Package has power "
          "applied to it (ie, is 'on').  For example, a disk drive "
          "Package inserted using SCA connectors is both Removable and "
          "HotSwappable.  All HotSwappable packages are inherently "
          "Removable and Replaceable.")]
   boolean HotSwappable;
    
      [Description (
          "The height of the PhysicalPackage in inches."), 
       Units ( "Inches" )]
   real32 Height;
    
      [Description (
          "The depth of the PhysicalPackage in inches."), 
       Units ( "Inches" )]
   real32 Depth;

      [Description (
          "The width of the PhysicalPackage in inches."), 
       Units ( "Inches" )]
   real32 Width;

      [Description (
          "The weight of the PhysicalPackage in pounds."), 
       Units ( "Pounds" )]
   real32 Weight;
    
      [Deprecated { "No Value" }, Description (
          "This method is being deprecated.  A PhysicalPackage cannot "
          "determine if it is compatible with another object.  The "
          "IsCompatible method verifies whether the referenced "
          "PhysicalElement may be contained by or inserted into the "
          "PhysicalPackage.  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 IsCompatible( 
         [IN, Description (
             "The element to check for compatibility with this one.")]
      CIM_PhysicalElement REF ElementToCheck);
};


// ===================================================================
// PhysicalFrame
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "PhysicalFrame is a superclass of Rack, Chassis and other frame "
       "enclosures, as they are defined in extension classes.  "
       "Properties like visible or audible alarm, and data related to "
       "security breaches are in this superclass.")]
class CIM_PhysicalFrame : CIM_PhysicalPackage {
    
    [Description ("CableManagementStrategy is a free-form string "
        "that contains information on how the various cables are "
        "connected and bundled for the Frame. With many networking, "
        "storage-related and power cables, cable management can be "
        "a complex and challenging endeavor. This string property "
        "contains information to aid in assembly and service "
        "of the Frame.") ]
    string CableManagementStrategy;
    
      [Description (
          "ServicePhilosophy is an enumerated, integer-valued array "
          "that indicates whether the Frame is serviced from the top "
          "(value=2), front (3), back (4) or side (5), whether it has "
          "sliding trays (6) or removable sides (7), and/or whether "
          "the Frame is moveable (8), for example, having rollers."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8" }, 
       Values { "Unknown", "Other", "Service From Top",
          "Service From Front", "Service From Back",
          "Service From Side", "Sliding Trays", "Removable Sides",
          "Moveable" }, ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_PhysicalFrame.ServiceDescriptions" }]
    uint16 ServicePhilosophy[];
    
      [Description (
          "An array of free-form strings providing more detailed "
          "explanations for any of the entries in the Service "
          "Philosophy array.  Note, each entry of this array is "
          "related to the entry in ServicePhilosophy that is located "
          "at the same index."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_PhysicalFrame.ServicePhilosophy" }]
    string ServiceDescriptions[];
    
    [Description ("Boolean indicating whether the Frame is protected "
        "with a lock.") ]
    boolean LockPresent;
    
    [Description ("Boolean indicating whether the Frame is equipped "
        "with an audible alarm.") ]
    boolean AudibleAlarm; 
    
    [Description ("Boolean indicating that the equipment includes "
        "a visible alarm.") ]
    boolean VisibleAlarm;
    
      [Description (
          "SecurityBreach is an enumerated, integer-valued property "
          "indicating whether a physical breach of the Frame was "
          "attempted but unsuccessful (value=4) or attempted and "
          "successful (5).  Also, the values, \"Unknown\", \"Other\" "
          "or \"No Breach\", can be specified."), 
       ValueMap { "1", "2", "3", "4", "5" }, 
       Values { "Other", "Unknown", "No Breach", "Breach Attempted",
          "Breach Successful" }, 
       MappingStrings { "MIF.DMTF|Physical Container Global " 
          "Table|004.12" }, 
       ModelCorrespondence { "CIM_PhysicalFrame.BreachDescription" }]
   uint16 SecurityBreach;

      [Description (
          "BreachDescription is a free-form string providing more "
          "information if the SecurityBreach property indicates that a "
          "breach or some other security-related event occurred."), 
       ModelCorrespondence { "CIM_PhysicalFrame.SecurityBreach" }]
   string BreachDescription;

      [Description (
          "Boolean indicating that the Frame is currently locked.")]
   boolean IsLocked;
};


// ===================================================================
// Chassis
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The Chassis class represents the PhysicalElements that enclose "
       "other Elements and provide definable functionality, such as a "
       "desktop, processing node, UPS, disk or tape storage, or a "
       "combination of these.")]
class CIM_Chassis : CIM_PhysicalFrame {
    
    [Description (
        "Integer indicating the number of power cords which must be "
        "connected to the Chassis, for all the componentry to "
        "operate.") ]
    uint16 NumberOfPowerCords;
    
      [Description (
          "Current required by the Chassis at 120V.  If power is "
          "provided by the Chassis (as in the case of a UPS), this "
          "property may indicate the amperage produced, as a negative "
          "number."), 
       Units ( "Amps at 120 Volts" )]
    sint16 CurrentRequiredOrProduced;
    
    [Description (
        "Amount of heat generated by the Chassis in BTU/hour."),
        Units ("BTU per Hour") ]
    uint16 HeatGeneration;
    
      [Deprecated { "CIM_Chassis.ChassisPackageType",
          "CIM_Chassis.MultipleSystemSupport" }, Description (
          "The use of this property is deprecated in lieu of "
          "ChassisPackageType.  A physical package should not have "
          "multiple form factors.  Therefore, this property is being "
          "deprecated in lieu of a single value property.  \n"
          "An enumerated, integer-valued array indicating the type of "
          "Chassis."), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
          "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
          "21", "22", "23", "24", "25" }, 
       Values { "Other", "Unknown", "Desktop", "Low Profile Desktop",
          "Pizza Box", "Mini Tower", "Tower", "Portable", "LapTop", 
          // 10       
          "Notebook", "Hand Held", "Docking Station", "All in One",
          "Sub Notebook", "Space-Saving", "Lunch Box",
          "Main System Chassis", "Expansion Chassis", "SubChassis", 
          // 20      
          "Bus Expansion Chassis", "Peripheral Chassis",
          "Storage Chassis", "Rack Mount Chassis", "Sealed-Case PC",
          "Multi-system Chassis" }, 
       MappingStrings { "MIF.DMTF|Physical Container Global " 
          "Table|004.1" }, ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_Chassis.TypeDescriptions" }]
    uint16 ChassisTypes[];
   
      [Deprecated { "CIM_Chassis.ChassisTypeDescription" }, 
       Description (
          "The use of this property is deprecated in lieu of a single "
          "value property, ChassisTypeDescription.  \n"
          "An array of free-form strings providing more information on "
          "the ChassisTypes array entries.  Note, each entry of this "
          "array is related to the entry in ChassisTypes that is "
          "located at the same index."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_Chassis.ChassisTypes" }]
    string TypeDescriptions[];

      [Description (
          "ChassisPackageType indicates the physical form factor for "
          "the type of Chassis."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
          "20", "21", "22", "23", "24", "25", "..", "0x8000..0xFFFF" }, 
       Values { "Unknown", "Other", "SMBIOS Reserved", "Desktop",
          "Low Profile Desktop", "Pizza Box", "Mini Tower", "Tower",
          "Portable", "LapTop", 
          // 10       
          "Notebook", "Hand Held", "Docking Station", "All in One",
          "Sub Notebook", "Space-Saving", "Lunch Box",
          "Main System Chassis", "Expansion Chassis", "SubChassis", 
          // 20      
          "Bus Expansion Chassis", "Peripheral Chassis",
          "Storage Chassis", "SMBIOS Reseved", "Sealed-Case PC",
          "SMBIOS Reserved", "DMTF Reserved", "Vendor Reserved" }, 
       MappingStrings { "MIF.DMTF|Physical Container Global " 
          "Table|004.1" }, 
       ModelCorrespondence { "CIM_Chassis.ChassisTypeDescription" }]
    uint16 ChassisPackageType;
 
      [Description (
          "A string providing more information on the "
          "ChassisPackageType."), 
       ModelCorrespondence { "CIM_Chassis.ChassisPackageType" }]
    string ChassisTypeDescription;
 
      [Description (
          "MultipleSystemSupport indicates whether or not this chassis "
          "supports multiple systems, for example server blades."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "True", "False" }]
    uint16 MultipleSystemSupport;
 
      [Description (
          "RackMountable indicates whether or not the chassis is Rack "
          "Mountable."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "True", "False" }]
    uint16 RackMountable;
};


// ===================================================================
// Card
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "The Card class represents a type of physical container that "
       "can be plugged into another Card or HostingBoard, or is itself "
       "a HostingBoard/Motherboard in a Chassis.  The CIM_Card class "
       "includes any package capable of carrying signals and providing "
       "a mounting point for PhysicalComponents, such as Chips, or "
       "other PhysicalPackages, such as other Cards.")]
class CIM_Card : CIM_PhysicalPackage {
    
    [Description (
        "Boolean indicating that this Card is a Motherboard or, "
        "more generically, a baseboard in a Chassis.") ]
    boolean HostingBoard;
    
    [Description (
        "SlotLayout is a free-form string that describes the "
        "slot positioning, typical usage, restrictions, individual "
        "slot spacings or any other pertinent information for the "
        "slots on a Card.") ]
    string SlotLayout;
    
    [Description (
        "Boolean indicating that at least one daughterboard or "
        "auxiliary Card is required in order to function properly.") ]
    boolean RequiresDaughterBoard;
    
    [Description ("Boolean indicating that this Card is physically "
        "unique from other Cards of the same type and therefore "
        "requires a special Slot. For example, a double-wide Card "
        "requires two Slots. Another example is where a certain Card "
        "may be used for the same general function as other Cards but "
        "requires a special Slot (e.g., extra long), whereas the "
        "other Cards can be placed in any available Slot. "
        "If set to TRUE, then the corresponding property, "
        "RequirementsDescription, should specify the nature of the "
        "uniqueness or purpose of the Card."),
        ModelCorrespondence{"CIM_Card.RequirementsDescription"} ]
    boolean SpecialRequirements;
    
    [Description ("A free-form string describing the way(s) in which "
        "this Card is physically unique from other Cards. This "
        "property only has meaning when the corresponding boolean "
        "property, SpecialRequirements, is set to TRUE."),
        ModelCorrespondence{"CIM_Card.SpecialRequirements"} ]
    string RequirementsDescription;
    
    [Description ("Operating voltages required by the Card."),
        Units("MilliVolts") ]
    sint16 OperatingVoltages[];
    
    [Description (
        "This method manipulates the power to a PhysicalConnector on "
        "a Card. It is intended to be used by a Card (especially by a "
        "motherboard - i.e., HostingBoard=TRUE) to turn the power on "
        "and off for a specific PhysicalConnector located on it. For "
        "example, in a personal computer, a system slot does not know "
        "how to turn itself on and off. However, the motherboard "
        "hosting this slot may have that capability. This is important "
        "in order to support hot swapping of an adapter card in a "
        "system slot. 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 ConnectorPower( 
         [IN, Description (
             "The connector to change the power setting for.")]
      CIM_PhysicalConnector REF Connector, 
         [IN, Description (
             "If TRUE, turn power on for the connector.  If FALSE, "
             "turn power off.")]
      boolean PoweredOn); 
};


// ===================================================================
// Identity
// ===================================================================
   [Version ( "2.8.0"), Description (
       "An instance of an Identity represents a ManagedElement that "
       "acts as a security principal within the scope in which it is "
       "defined and authenticated. (Note that the Identity's scope is "
       "specified using the association, CIM_IdentityContext.) "
       "ManagedElements with Identities can be OrganizationalEntities, "
       "Services, Systems, etc. The ManagedElement 'behind' an "
       "Identity is described using the AssignedIdentity association. \n"
       "\n"
       "Within a given security context, an Identity may be imparted a "
       "level of trust, usually based on its credentials. A trust "
       "level is defined using the CIM_SecuritySensitivity class, and "
       "associated with Identity using CIM_ElementSecuritySensitivity. " 
       "Whether an Identity is currently authenticated is "
       "evaluated by checking the CurrentlyAuthenticated boolean "
       "property. This property is set and cleared by the security "
       "infrastructure, and should only be readable within the "
       "management infrastructure. The conditions which must be "
       "met/authenticated in order for an Identity's "
       "CurrentlyAuthenticated Boolean to be TRUE are defined using a "
       "subclass of PolicyCondition - AuthenticationCondition. The "
       "inheritance tree for AuthenticationCondition is defined in the "
       "CIM Policy Model. \n"
       "\n"
       "Subclasses of Identity may include specific information "
       "related to a given AuthenticationService or authority (such as "
       "a security token or computer hardware port/communication "
       "details) that more specifically determine the authenticity of "
       "the Identity.  An instance of Identity may be persisted even "
       "though it is not CurrentlyAuthenticated, in order to maintain "
       "static relationships to Roles, associations to accounting "
       "information, and policy data defining authentication "
       "requirements.  Note however, when an Identity is not "
       "authenticated (CurrentlyAuthenticated = FALSE), then "
       "Privileges or rights SHOULD NOT be authorized.  The lifetime, "
       "validity, and propagation of the Identity is dependent on a "
       "security infrastructure's policies.") ]
class CIM_Identity : CIM_ManagedElement {  

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority. (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace. \n"
          "For DMTF defined instances, the 'preferred' algorithm "
          "MUST be used with the <OrgID> set to 'CIM'.") ]        
   string InstanceID;

      [Description (
          "Boolean indicating whether this Identity has been "
          "authenticated, and is currently known within the scope of "
          "an AuthenticationService or authority.  By default, "
          "authenticity SHOULD NOT be assumed.  This property is set "
          "and cleared by the security infrastructure, and should only "
          "be readable within the management infrastructure.  Note "
          "that its value, alone, may not be sufficient to determine "
          "authentication/ authorization, in that properties of an "
          "Identity subclass (such as a security token or computer "
          "hardware port/ communication details) may be required by "
          "the security infrastructure.") ]
   boolean CurrentlyAuthenticated = FALSE;
};


// ===================================================================
// StorageHardwareID
// ===================================================================
   [Version ( "2.8.0"), Description (
       "CIM_StorageHardwareID is a hardware ID that serves as an "
       "authorization subject.  Example are host controller IDs that "
       "serve as authorization subjects in disk array LUN Masking.") ]
class CIM_StorageHardwareID : CIM_Identity {

      [Required, Description (
          "The hardware worldwide unique ID."), 
       MaxLen ( 256), 
       ModelCorrespondence { "CIM_StorageHardwareID.IDType"} ]
   string StorageID;

      [Required, Description (
          "The type of the ID property."), 
       ValueMap { "1", "2", "3", "4"}, 
       Values { "Other", "PortWWN", "NodeWWN", "Hostname"}, 
       ModelCorrespondence { "CIM_StorageHardwareID.StorageID"} ]
   uint16 IDType;

      [Description (
          "The ID type when IDType is \"Other\".") ]
   string OtherIDType;
};


// ===================================================================
// Product
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "CIM_Product is a concrete class that aggregates "
       "PhysicalElements, software (SoftwareIdentity and "
       "SoftwareFeatures), Services and/or other Products, and is "
       "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.  \n"
       "Note that software is handled a bit differently in the list of "
       "aggregated entities, above.  This is because software can be "
       "viewed as a tangible asset (similar to PhysicalElements) AND/ "
       "OR as a set of features that make up a Product and are "
       "deployed.  These are two different concepts, usually managed "
       "by different units in a business' organization.  When software "
       "'features' are described, the CIM_SoftwareFeature class from "
       "the Application Model is instantiated (where Features are Weak "
       "to/scoped by a Product).  When a specific piece of software is "
       "acquired and perhaps warrantied as part of a Product, this is "
       "addressed by the class, SoftwareIdentity.")]
class CIM_Product : CIM_ManagedElement {

      [Key, Description (
          "Commonly used Product name."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIF.DMTF|ComponentID|001.2" }, 
       ModelCorrespondence { "PRS_Product.ProductName" }]
   string Name;

      [Key, 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."), 
       MaxLen ( 64 ), 
       MappingStrings { "MIF.DMTF|ComponentID|001.4" }]
   string IdentifyingNumber;
    
      [Key, 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."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIF.DMTF|ComponentID|001.1" }, 
       ModelCorrespondence { "PRS_Product.Vendor" }]
   string Vendor;

      [Key, Description (
          "Product version information."), 
       MaxLen ( 64 ), 
       MappingStrings { "MIF.DMTF|ComponentID|001.3" }, 
       ModelCorrespondence { "PRS_Product.Version" }]
   string Version;

      [Description (
          "Product SKU (stock keeping unit) information."), 
       MaxLen ( 64 )]
   string SKUNumber;
      
      [Description (
          "If this Product is under warranty, the start date of the "
          "warranty."), 
       MappingStrings { "MIF.DMTF|FRU|002.9" }, 
       ModelCorrespondence { "CIM_Product.WarrantyDuration" }]
   datetime WarrantyStartDate;

      [Description (
          "If this Product is under warranty, the duration of the "
          "warranty in days."), 
       Units ( "Days" ), 
       MappingStrings { "MIF.DMTF|FRU|002.10" }, 
       ModelCorrespondence { "CIM_Product.WarrantyStartDate" }]
   uint32 WarrantyDuration;
};


// ===================================================================
// Capabilities
// ===================================================================
   [Abstract, Version ( "2.7.0" ), Description (
       "Capabilities is an abstract class whose subclasses describe "
       "abilities and/or potential for use.  For example, one may "
       "describe the maximum number of VLANs that can be supported on "
       "a system using a subclass of Capabilities.  Capabilities are "
       "tied to the elements which they describe using the "
       "ElementCapabilities association.  Note that the cardinality of "
       "the ManagedElement reference is Min(1), Max(1).  This "
       "cardinality mandates the instantiation of the "
       "ElementCapabilities association for the referenced instance of "
       "Capabilities.  ElementCapabilities describes the existence "
       "requirements and context for the referenced instance of "
       "ManagedElement.  Specifically, the ManagedElement MUST exist "
       "and provides the context for the Capabilities.  Note that "
       "Capabilities do not indicate what IS configured or "
       "operational, but what CAN or CANNOT exist, be defined or be "
       "used.  Note that it is possible to describe both supported and "
       "excluded abilities and functions (both capabilities and "
       "limitations) using this class.")]
class CIM_Capabilities : CIM_ManagedElement { 

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nFor DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]
   string InstanceID;

      [Required, Override ( "ElementName" ), Description (
          "The user friendly name for this instance of Capabilities.  "
          "In addition, the user friendly name can be used as a index "
          "property for a search of query.  (Note: Name does not have "
          "to be unique within a namespace.)")]
   string ElementName;
};


// ===================================================================
// StorageCapabilities
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A subclass of Capabilities that defines the Capabilities of a "
       "StorageService or StoragePool.  For example, an instance of "
       "StorageCapabilities could be associated with either a "
       "StorageConfigurationService or StoragePool by using "
       "ElementCapabilities.")]
class CIM_StorageCapabilities : CIM_Capabilities {
 
    [Description (
        "Enumeration indicating the type of element to which this "
        "StorageCapabilities applies."),
        ValueMap{"0", "1", "2", "3", "4", "5", "6"},
        Values {"Unknown", "Reserved", "Any Type", "StorageVolume", 
            "StorageExtent", "StoragePool", 
            "StorageConfigurationService"} ]
    uint16 ElementType;
 
    [Description (
        "Indicates whether or not the associated element supports "
        "no single point of failure.  Values are: "
        "FALSE = does not support no single point of failure, "
        "and TRUE = supports no single point of failure."),
        ModelCorrespondence {
            "CIM_StorageCapabilities.NoSinglePointOfFailureDefault"} ]
    boolean NoSinglePointOfFailure;
 
    [Description (
        "Indicates the default value for the NoSinglePointOfFailure "
        "property."),
        ModelCorrespondence {
            "CIM_StorageCapabilities.NoSinglePointOfFailure"} ]
    boolean NoSinglePointOfFailureDefault;
 
      [Description (
          "DataRedundancyMax describes the maximum number of complete "
          "copies of data that can be maintained.  Examples would be "
          "RAID 5 (where 1 copy is maintained) and RAID 1 (where 2 or "
          "more copies are maintained).  Possible values are 1 to n.  "
          "The default redundancy is specified using "
          "DataRedundancyDefault, while the minimum is defined by "
          "DataRedundancyMin."), 
       MinValue ( 1 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DataRedundancyMin",
          "CIM_StorageCapabilities.DataRedundancyDefault" }]
    uint16 DataRedundancyMax;
 
      [Description (
          "DataRedundancyMin describes the minimum number of complete "
          "copies of data that can be maintained.  Examples would be "
          "RAID 5 where 1 copy is maintained and RAID 1 where 2 or "
          "more copies are maintained).  Possible values are 1 to n.  "
          "The default redundancy is specified using "
          "DataRedundancyDefault, while the maximum is defined by "
          "DataRedundancyMax."), 
       MinValue ( 1 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DataRedundancyMax",
          "CIM_StorageCapabilities.DataRedundancyDefault" }]
    uint16 DataRedundancyMin;
 
      [Description (
          "DataRedundancyDefault describes the default number of "
          "complete copies of data that can be maintained.  Examples "
          "would be RAID 5 where 1 copy is maintained and RAID 1 where "
          "2 or more copies are maintained.  Possible values are 1 to "
          "n.  The bounds for the redundancy (max and min) are defined "
          "by DataRedundancyMax and DataRedundancyMin."), 
       MinValue ( 1 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DataRedundancyMax",
          "CIM_StorageCapabilities.DataRedundancyMin" }]
    uint16 DataRedundancyDefault;
 
      [Description (
          "PackageRedundancyMax describes the maximum number of "
          "redundant packages that can be used.  For example, in the "
          "storage domain, package redundancy describes how many disk "
          "spindles can fail without data loss including, at most, one "
          "spare.  An example would be RAID5 with a spare disk which "
          "would have a PackageRedundancy of 2.  Possible values are 0 "
          "to n.  The default redundancy is specified using "
          "PackageRedundancyDefault, while the maximum is defined by "
          "PackageRedundancyMax."), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.PackageRedundancyMin",
          "CIM_StorageCapabilities.PackageRedundancyDefault" }]
    uint16 PackageRedundancyMax;
 
      [Description (
          "PackageRedundancyMin describes the minimum number of "
          "redundant packages that can be used.  For example, in the "
          "storage domain, package redundancy describes how many disk "
          "spindles can fail without data loss including, at most, one "
          "spare.  An example would be RAID5 with a spare disk which "
          "would have a PackageRedundancy of 2.  Possible values are 0 "
          "to n.  The default redundancy is specified using "
          "PackageRedundancyDefault, while the minimum is defined by "
          "PackageRedundancyMin."), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.PackageRedundancyMax",
          "CIM_StorageCapabilities.PackageRedundancyDefault" }]
    uint16 PackageRedundancyMin;
 
      [Description (
          "PackageRedundancyDefault describes the default number of "
          "redundant packages that will be used.  For example, in the "
          "storage domain, package redundancy describes how many disk "
          "spindles can fail without data loss including, at most, one "
          "spare.  An example would be RAID5 with a spare disk which "
          "would have a PackageRedundancy of 2.  Possible values are 0 "
          "to n.  The bounds for redundancy are specified using the "
          "properties, PackageRedundancyMax and PackageRedundancyMin."), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.PackageRedundancyMin",
          "CIM_StorageCapabilities.PackageRedundancyMax" }]
    uint16 PackageRedundancyDefault;
 
      [Description (
          "DeltaReservatioMax is a number between 1 (1%) and a 100 "
          "(100%) that specifies the maximum amount of space reserved "
          "in a replica for caching changes.  For a complete copy this "
          "would be 100%, but it can be lower in some "
          "implementations.  This parameter sets the upper limit, "
          "while DeltaReservationMin sets the lower limit."), 
       Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DeltaReservationMin",
          "CIM_StorageCapabilities.DeltaReservationDefault" }]
    uint16 DeltaReservationMax;
 
      [Description (
          "DeltaReservationMin is a number between 1 (1%) and a 100 "
          "(100%) that specifies the minimum amount of space that "
          "should be reserved in a replica for caching changes.  For a "
          "complete copy this would be 100%, but it can be lower in "
          "some implementations.  This parameter sets the lower limit, "
          "while DeltaReservationMax sets the upper limit."), 
       Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DeltaReservationMax",
          "CIM_StorageCapabilities.DeltaReservationDefault" }]
    uint16 DeltaReservationMin;
 
      [Description (
          "Delta reservation is a number between 1 (1%) and a 100 "
          "(100%) that specifies how much space should be reserved by "
          "default in a replica for caching changes.  For a complete "
          "copy this would be 100%, but it can be lower in some "
          "implementations.  This parameter sets the default value, "
          "while DeletaReservationMax and DeltReservationMin set the "
          "upper and lower bounds."), 
       Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ), 
       ModelCorrespondence { 
          "CIM_StorageCapabilities.DeltaReservationMax",
          "CIM_StorageCapabilities.DeltaReservationMin" }]
    uint16 DeltaReservationDefault;

      [Description (
          "Method to create and populate a StorageSetting instance "
          "from a StorageCapability instance.  This removes the need "
          "to populate default settings and other settings in the "
          "context of each StorageCapabilities (which could be "
          "numerous).  If the underlying instrumentation supports the "
          "StorageSettingWithHints subclass, then an instance of that "
          "class will be created instead."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "..", "32768..65535" }, 
       Values { "Success", "Not Supported", "Unspecified Error",
          "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
          "Vendor Specific" }]
   uint32 CreateSetting ( 
         [IN, Description (
             "If 'Default' is passed for the CreateDefault parameter, "
             "the Max, Goal, and Min setting attributes are set to the "
             "Default values of the parent StorageCapabilities when "
             "the instance is created.  \n"
             "If set to 'Goal' the new StorageSetting attributes are "
             "set to the related attributes of the parent "
             "StorageCapabilities, e.g.  Min to Min, Goal to Default, "
             "and Max to Max.  \n"
             "\n"
             "This method maybe deprecated in lieu of intrinsics once "
             "limitations in the CIM Operations are addressed."), 
          ValueMap { "2", "3" }, 
          Values { "Default", "Goal" }]
      uint16 SettingType, 
         [IN ( False ), OUT, Description (
             "Reference to the created StorageSetting instance.")]
      CIM_StorageSetting REF NewSetting ); 
};


// ===================================================================
// ProtocolControllerMaskingCapabilities
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A subclass of Capabilities that defines the Masking-related "
       "capabilities of a ProtocolController.")]
class CIM_ProtocolControllerMaskingCapabilities : CIM_Capabilities {

      [Description (
          "A list of the valid values for StrorageHardwareID.IDType."), 
       ValueMap {"1", "2", "3", "4"}, 
       Values {"Other", "Port WWN", "Node WWN", "Host Name"}, 
       ArrayType ("Indexed") ]
   uint16 ValidHardwareIdTypes[];

      [Description (
          "An array of strings describing types for valid "
          "StorageHardwareID.IDType.  Used when the "
          "ValidHardwareIdTypes includes 1 (\"Other\")."), 
       ArrayType ("Indexed") ]
   string OtherValidHardwareIDTypes[];
   
      [Description (
          "An integer enumeration indicating the way that ports per "
          "view (ProtocolController) are handled by the underlying "
          "storage system."), 
       ValueMap { "2", "3", "4" }, 
       Values { "One Port per View", "Multiple Ports per View",
          "All Ports share the same View" }]
   uint16 PortsPerView = 3; //@15483C

//      [Description (
//          "Set to true to indicate the associated storage system "
//          "allows ProtocolControllers with different authorization "
//          "permissions or initiators associated with a subset of the "
//          "storage system's ports.  Set to false to indicate that the "
//          "associated storage system always grants access to "
//          "initiators identically through all storage system ports.") ]
//   boolean AccessControlByPorts = TRUE;

      [Description (
          "Set to true if this storage system allows the client to "
          "specify the DeviceNumber parameter when calling "
          "ControllerConfigurationService.AttachDevice() and "
          "ControllerConfigurationService.AttachDevice() and Set to "
          "false if the implementation does not allow unit numbers to "
          "vary for a ProtocolController.  However, if set to false "
          "and a Device is not the Dependent of a "
          "ProtocolControllerForUnit association, the client must "
          "provide a DeviceNumber parameter in "
          "ControllerConfigurationService.AttachDevice.  If set to "
          "false and the Device is already the Dependent of a "
          "ProtocolControllerForUnit association, then the client can "
          "omit the DeviceNumber parameter (or supply the same value) "
          "in subsequent ControllerConfigurationService.AttachDevice "
          "calls.")]
   boolean ClientSelectableDeviceNumbers = TRUE;

      [Description (
          "Set to true if this storage system supports the "
          "AttachDevice method.") ]
   boolean AttachDeviceSupported;

      [Description (
          "Set to true if this storage system limits configurations to "
          "a single subject hardware ID per view.  Otherwise, multiple "
          "hardware ID types can be used.  The default is FALSE, that "
          "multiple ID types may be used in a single view.") ]
   boolean OneHardwareIDPerView = FALSE;

      [Description (
          "Set to true if this storage system limits configurations to "
          "a single port per view.  Otherwise, multiple ports can be "
          "included.  The default is FALSE, that multiple ports may be "
          "included in a single view.") ]
   boolean OnePortPerView = FALSE;

      [Description (
          "When set to false, different ProtocolContollers attached to "
          "a LogicalPort can expose the same unit numbers.  If true, "
          "then this storage system requires unique unit numbers "
          "across all the ProtocolControllers connected to a "
          "LogicalPort.") ]
   boolean UniqueUnitNumbersPerPort = FALSE;

      [Description (
          "Set to true if this storage system allows a client to "
          "create a Privilege instance with PrivilegeGranted set to "
          "FALSE.") ]
   boolean PrivilegeDeniedSupported = FALSE;

      [Description (
          "If true, this property indicates that at least one "
          "Privilege/Identity pair must be specified when "
          "CreateProtocolController() is called.") ]
   Boolean ProtocolControllerRequiresAuthorizedIdentity = TRUE; //@15483C

	  [Description (
          "If true, this property indicates that the Identity "
          "parameter of CreateProtocolConntrollerWithPorts() MUST "
          "contain a reference to a CIM_Collection (or subclass) or to "
          "a CIM_Identity (or subclass).")]
   boolean ProtocolControllerSupportsCollections = FALSE;
};


// ===================================================================
// SettingData
// ===================================================================
   [Abstract, Version ( "2.7.0" ), Description (
       "The SettingData class represents configuration-related and "
       "operational parameters for one or more ManagedElement(s).  A "
       "ManagedElement may have multiple SettingData 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 "
       "SettingData object.  For example, a modem may have a "
       "SettingData baud rate of 56Kb/sec but be operating at "
       "19.2Kb/sec.  \n"
       "Note that the CIM_SettingData class is very similar to "
       "CIM_Setting, yet both classes are present in the model.  This "
       "is because many implementations have successfully used "
       "CIM_Setting.  However, issues have arisen that could not be "
       "resolved without defining a new class.  Therefore, until a new "
       "major release occurs, both classes will exist in the model.  "
       "Refer to the Core White Paper for additional information.")]
class CIM_SettingData : CIM_ManagedElement {
    
      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nForDMTFdefined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]        
    string InstanceID;

    [Override ("ElementName"), Required, Description (
        "The user friendly name for this instance of SettingData. "
        "In addition, the user friendly name can be used as a "
        "index property for a search of query.  (Note:  Name "
        "does not have to be unique within a namespace.)") ]
    string ElementName;
};


// ===================================================================
// StorageSetting
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "StorageSetting is roughly equivalent to a Service Level "
       "Agreement (SLA) It defines the characteristics, qualities of "
       "service and goals when used in a CreateOrModifyElement "
       "FromStoragePool or CreateOrModifyStoragePool method in the "
       "StorageConfigurationService.  It specifies a series of "
       "properties with Maximum and Minimum values that define the "
       "(inclusive) bounds that the object should maintain.  Note that "
       "the setting is associated to a StorageVolume, using "
       "ElementSetting.")]
class CIM_StorageSetting : CIM_SettingData {
        
    [Write, Description (
        "Indicates the desired value for No Single Point of Failure. "
        "Possible values are false = single point of failure, and "
        "true = no single point of failure.") ]
    boolean NoSinglePointOfFailure;
 
      [Write, Description (
          "DataRedundancyMax describes the maximum number of complete "
          "copies of data to be maintained.  Examples would be RAID 5 "
          "where 1 copy is maintained and RAID 1 where 2 or more "
          "copies are maintained.  Possible values are 1 to n.  The "
          "desired redundancy is specified using DataRedundancyGoal, "
          "while the minimum is defined by DataRedundancyMin."), 
       MinValue ( 1 ), 
       ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMin",
          "CIM_StorageSetting.DataRedundancyGoal" }]
    uint16 DataRedundancyMax;
 
      [Write, Description (
          "DataRedundancyMin describes the minimum number of complete "
          "copies of data to be maintained.  Examples would be RAID 5 "
          "where 1 copy is maintained and RAID 1 where 2 or more "
          "copies are maintained.  Possible values are 1 to n.  The "
          "desired redundancy is specified using DataRedundancyGoal, "
          "while the maximum is defined by DataRedundancyMax."), 
       MinValue ( 1 ), 
       ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMax",
          "CIM_StorageSetting.DataRedundancyGoal" }]
    uint16 DataRedundancyMin;
 
      [Write, Description (
          "DataRedundancyGoal describes the desired number of complete "
          "copies of data to be maintained.  Examples would be RAID 5 "
          "where 1 copy is maintained and RAID 1 where 2 or more "
          "copies are maintained.  Possible values are 1 to n.  The "
          "bounds (max and min) for redundancy are defined using the "
          "properties, DataRedundancyMax and DataRedundancyMin."), 
       MinValue ( 1 ), 
       ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMax",
          "CIM_StorageSetting.DataRedundancyMin" }]
    uint16 DataRedundancyGoal;
 
      [Write, Description (
          "PackageRedundancyMax describes the maximum number of "
          "redundant packages to be used.  For example, in the storage "
          "domain, package redundancy describes how many disk spindles "
          "can fail without data loss including, at most, one spare.  "
          "An example would be RAID5 with a spare disk which would "
          "have a PackageRedundancy of 2.  Possible values are 0 to "
          "n.  The desired redundancy is specified using "
          "PackageRedundancyGoal, while the minimum is defined by "
          "PackageRedundancyMin."), 
       ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMin",
          "CIM_StorageSetting.PackageRedundancyGoal" }]
     uint16 PackageRedundancyMax;
 
      [Write, Description (
          "PackageRedundancyMin describes the minimum number of "
          "redundant packages to be used.  For example, in the storage "
          "domain, package redundancy describes how many disk spindles "
          "can fail without data loss including, at most, one spare.  "
          "An example would be RAID5 with a spare disk which would "
          "have a PackageRedundancy of 2.  Possible values are 0 to "
          "n.  The desired redundancy is specified using "
          "PackageRedundancyGoal, while the maximum is defined by "
          "PackageRedundancyMax."), 
       ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMax",
          "CIM_StorageSetting.PackageRedundancyGoal" }]
     uint16 PackageRedundancyMin;
 
      [Write, Description (
          "PackageRedundancyGoal describes the desired number of "
          "redundant packages to be used.  For example, in the storage "
          "domain, package redundancy describes how many disk spindles "
          "can fail without data loss including, at most, one spare.  "
          "An example would be RAID5 with a spare disk which would "
          "have a PackageRedundancy of 2.  Possible values are 0 to "
          "n.  The bounds (max and min) for redundancy are defined "
          "using the properties, PackageRedundancyMax and "
          "PackageRedundancyMin."), 
       ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMax",
          "CIM_StorageSetting.PackageRedundancyMin" }]
     uint16 PackageRedundancyGoal;
  
      [Write, Description (
          "DeltaReservationMax is a number between 1 (1%) and a 100 "
          "(100%) which specifies the maximum amount of space that "
          "should be reserved in a replica for caching changes.  For a "
          "complete copy this would be 100%.  The desired reservation "
          "is specified using DeltaReservationGoal, while the minimum "
          "is defined by DeltaReservationMin."), 
       Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ), 
       ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMin",
          "CIM_StorageSetting.DeltaReservationGoal" }]
   uint8 DeltaReservationMax;
 
      [Write, Description (
          "DeltaReservationMin is a number between 1 (1%) and a 100 "
          "(100%) which specifies the minimum amount of space that "
          "should be reserved in a replica for caching changes.  For a "
          "complete copy this would be 100%.  The desired reservation "
          "is specified using DeltaReservationGoal, while the maximum "
          "is defined by DeltaReservationMax."), 
       Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ), 
       ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMax",
          "CIM_StorageSetting.DeltaReservationGoal" }]
   uint8 DeltaReservationMin;
 
      [Write, Description (
          "DeltaReservationGoal is a number between 1 (1%) and a 100 "
          "(100%) which specifies the desired amount of space that "
          "should be reserved in a replica for caching changes.  For a "
          "complete copy this would be 100%.  The bounds (max and min) "
          "for the reservation are defined using the properties, "
          "DeltaReservationMax and DeltaReservationMin."), 
       Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ), 
       ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMin",
          "CIM_StorageSetting.DeltaReservationMax" }]
   uint8 DeltaReservationGoal;
};


// ===================================================================
// StorageClientSettingData
// ===================================================================
   [Version ( "2.8.0"), Description (
       "This class models host environment factors that influence the "
       "behavior of Storage Systems.  For example, a disk array has "
       "different SCSI responses for clients (initiators) configured "
       "as AIX verses HPUX.  Instances of this setting class can be "
       "associated via ElementSettingData to a storage system's "
       "LogicalPort, ProtocolController, or Volume instances when "
       "these elements have host awareness.  These associations are "
       "created by the management instrumentation provider to reflect "
       "the current configuration.  A client deletes/creates these "
       "associations to request changes in element host-awareness.  "
       "This settings class can also be associated with "
       "StorageHardwareID instances when that HW ID is configured with "
       "host information.  An instance of this setting may include "
       "several ClientType values if the storage system treats them "
       "identically.  The storage system exposes all supported setting "
       "instances to a WBEM Enumerate request; the client uses the "
       "returned settings to determine which types are available.") ]
class CIM_StorageClientSettingData : CIM_SettingData {

      [Description (
          "This enumeration defines operating system, version, driver, "
          "and other host environment factors that influence the "
          "behavior exposed by storage systems.  Values in this array "
          "are combined with data from the OtherClientTypeDescriptions "
          "property to provide complete information on the host "
          "environment."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "12", "13", "14", "15", "16", "17", "18",
          "19..32767", "32768..65535" }, 
       Values { "Unknown", "Other", "Standard", "Solaris", "HPUX",
          "OpenVMS", "Tru64", "Netware", "Sequent", "AIX", "DGUX",
          "Dynix", "Irix", "Cisco iSCSI Storage Router", "Linux",
          "Microsoft Windows", "OS400", "TRESPASS", "HI-UX",
          "DMTF Reserved", "Vendor Specific" }, 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { 
          "CIM_StorageClientSettingData.OtherClientTypeDescriptions"} ]
    uint16 ClientTypes[];

      [Description (
          "When the the corresponding array entry in ClientTypes[] is "
          "\"Other\", this entry provides a string describing the "
          "manufacturer and OS/Environment.  When the corresponding "
          "ClientTypes[] entry is not \"Other\", this entry allows "
          "variations or qualifications of ClientTypes - for example, "
          "different versions of Solaris."), 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { 
          "CIM_StorageClientSettingData.ClientTypes"} ]
    string OtherClientTypeDescriptions[];
};


// ===================================================================
// InitiatorSettingData
// ===================================================================
[Experimental, Version ("2.8.0"), Description (
    "This class models host environment that influence the behavior of "
    "Storage Systems.  For example, a disk array has different SCSI "
    "responses for initiators configured as AIX verses HPUX. "
    "Instances of this setting class are associated via "
    "ElementSettingData to device Ports, ProtocolControllers, or "
    "Volumes instances when these elements have host awareness. "
    "These associations are created by the provider to reflect the "
    "current configuration.  A client deletes/creates these "
    "associations to request changes in element host-awareness. \n"
    "This settings class is also associated with StorageHardwareID "
    "instances when that HW ID is configured with host information. \n "
    "An instance of this setting may include several InitiatorType "
    "values if the storage system treats them identically. \n"
    "The storage system exposes all supported setting instances to "
    "an enumerate request; the client uses the returned settings to "
    "determine which types are available. ") ]
class CIM_InitiatorSettingData : CIM_SettingData
{
    [Experimental, Description (
        "These names map to combinations of OperatingSystem, Version, "
        "Driver, and other host environment factors that influence the "
        "behavior exposed by storage systems."),
         ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
            "10", "11", "12", "13", "14", "15", "16", "17", "18", 
            "..", "0x8000.." },
         Values {"Unknown", "Other", "Standard", "Solaris", "HPUX",
            "OpenVMS", "Tru64", "Netware", "Sequent", "AIX", "DGUX",
            "Dynix", "Irix", "Cisco iSCSI Storage Router", "Linux", 
            "Microsoft Windows", "OS400", "TRESPASS", "HI-UX", 
            "DMTF Reserved", "Vendor Specific" },
        ArrayType ("Indexed"),  
        ModelCorrespondence {
            "CIM_InitiatorSetttingData.InitiatorTypeQualifiers",
            "CIM_InitiatorSetttingData.OtherInitiatorTypeDescriptions"} ]
    uint16 InitiatorTypes[];

    [Experimental, Description (
        "Array entries correspond to entries in InitiatorTypes to allow "
        "variations or qualifications of InitiatorTypes - for example, "
        "different versions of Solaris."),
        ArrayType ("Indexed"),
        ModelCorrespondence {"CIM_InitiatorSetttingData.InitiatorTypes",
            "CIM_InitiatorSetttingData.OtherInitiatorTypeDescriptions"} ]
        string InitiatorTypeQualifiers[];

    [Description (
        "A string describing the manufacturer and OS/Environment - used "
        "when the InitiatorTypes, includes \"Other\". "),
        MaxLen (64),
        ArrayType ("Indexed"),
        ModelCorrespondence {"CIM_InitiatorSetttingData.InitiatorTypes",
            "CIM_InitiatorSetttingData.InitiatorTypeQualifiers"} ]
    string OtherInitiatorTypeDescriptions[];
};


// ===================================================================
// 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 {
};


// ===================================================================
// SystemSpecificCollection
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "SystemSpecificCollection represents the general concept of a "
       "collection which is scoped (or contained) by a System.  It "
       "represents a Collection that only has meaning in the context "
       "of a System, and/or whose elements are restricted by the "
       "definition of the System.  This is explicitly described by the "
       "(required) association, HostedCollection.  \n"
       "An example of a SystemSpecificCollection is a Fibre Channel "
       "zone that collects network ports, port groupings and aliases "
       "(as required by a customer) in the context of an AdminDomain.  "
       "The Collection is not a part of the domain, but merely an "
       "arbitrary grouping of the devices and other Collections in the "
       "domain.  In other words, the context of the Collection is "
       "restricted to the domain, and its members are also limited by "
       "the domain.")]
class CIM_SystemSpecificCollection : CIM_Collection {

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nFor DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]       
    string InstanceID;
};


// ===================================================================
// RedundancySet
// ===================================================================
[Experimental, Version ("2.7.1000"), Description (
    "  A class derived from SystemSpecificCollection that is a special "
    "collection of ManagedElements. This collection indicates "
    "that the aggregated elements together provide redundancy, or "
    "that redundancy is provided via sparing. All elements "
    "collected in a RedundancySet should be instantiations of the "
    "same object class. \n"
    "  Note that the CIM_RedundancySet class is very similar to "
    "CIM_RedundancyGroup, yet both classes are present in the model.  "
    "This is because some implementations have successfully used "
    "CIM_RedundancyGroup.  However, issues have arisen that could not "
    "be resolved without defining a new class.  Therefore, until a "
    "new major release occurs, both classes will exist in the model. "
    "Refer to the Core White Paper for additional information.") ]
class CIM_RedundancySet : CIM_SystemSpecificCollection {
    
    [Override ("ElementName"), Required, Description (
        "The user friendly name for this instance of RedundancySet. "
        "In addition, the user friendly name can be used as a "
        "property for a search or query.  (Note:  InstanceName "
        "does not have to be unique within a namespace.)") ]
    string ElementName;
   
    [Description (
        "RedundancyStatus provides information on the state of "
        "the RedundancySet. \n"
        " - Fully Redundant (=2) means that all of the "
        "configured redundancy is still available. \n "
        " - Degraded Redundancy (=3) means that some failures "
        "have been experienced but some reduced amount of "
        "redundancy is still available \n"
        " - Redundancy Lost (=4) means that a sufficient number "
        "of failures have been experienced such that no "
        "redundancy is available and the next failure "
        "experienced will cause overall failure."), 
        ValueMap {"0", "1", "2", "3", "4"},
        Values {"Unknown", "Other", "Fully Redundant", 
            "Degraded Redundancy", "Redundancy Lost"} ]
    uint16 RedundancyStatus;
};


// ===================================================================
// ExtraCapacitySet
// ===================================================================
[Experimental, Version ("2.7.1000"), Description (
    "A class derived from RedundancySet to describe that the "
    "aggregated elements have more capacity or capability than is "
    "needed.  Some examples of this type of redundancy are clusters, "
    "or the installation of N+1 power supplies or fans in a "
    "computer.") ] 
class CIM_ExtraCapacitySet : CIM_RedundancySet {

    [Description (
        "MinNumberNeeded indicates the smallest number of elements "
        "that must be operational in order to function.  "
        "For example, in an N+1 redundancy relationship, "
        "the MinNumberNeeded property is set equal to N."),
        MinValue (1) ]
    uint32 MinNumberNeeded;

    [Description (
        "MaxNumberSupported indicates the largest number of "
        "elements that can participate in the ExtraCapacitySet. "
        "A value of 0 indicates there is no limit on the number "
        "of elements.") ]
    uint32 MaxNumberSupported;  
   
    [Description (
        "Boolean indicating whether load balancing is supported by "
        "the ExtraCapacitySet.") ]
    boolean LoadBalancedSet; 
};


// ===================================================================
// SynchronizedSet
// ===================================================================
[Version ("2.8.0"), Description ("CR from IBM") ]
class CIM_SynchronizedSet : CIM_SystemSpecificCollection
{
    [Experimental, Description(
            "The user friendly name for this instance of ConsistencySet. In addition, "
            "the user friendly name can be used as a property for a search or query. "
            "(Note: ElementName does not have to be unique within a namespace.)")]
    string ElementName;

    [Experimental,  
        Description(
            "CopyType describes the Replication Policy."
            "Values are:  \n"
            "  Async: create and maintain an asynchronous \n"
            "        copy of the source. \n"
            "  Sync: create and maintain a synchronized copy \n"
            "        of the source. \n"
            "  UnSyncAssoc: create an unsynchronized copy and \n"
            "        maintain an association to the source."),
        ValueMap {"2", "3", "4", "..", "0x8000.."},
        Values {"Async", "Sync", "UnSyncAssoc", "DMTF Reserved", "Vendor Specific"} ]
    uint16 CopyType;
};


// ===================================================================
// RegisteredProfile
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A RegisteredProfile describes a set of CIM Schema classes with "
       "required properties and/or methods, necessary to manage a "
       "real-world entity or to support a usage scenario, in an "
       "interoperable fashion.  RegisteredProfiles can be defined by "
       "the DMTF or other standards organizations.  Note that this "
       "class should not be confused with CIM_Profile, which collects "
       "SettingData instances, to be applied as a 'configuration "
       "profile' for an element.  \n"
       "A RegisteredProfile is a named 'standard' for CIM-based "
       "management of a particular System, subsystem, Service or other "
       "entity, for a specified set of uses.  It is a complete, "
       "standalone definition, as opposed to the subclass "
       "RegisteredSubProfile, which requires a scoping profile for "
       "context.  \n"
       "The uses for a RegisteredProfile or SubProfile MUST be "
       "specified in the document that defines the profile.  Examples "
       "of Profiles are to manage various aspects of an Operating "
       "System, Storage Array, or Database.  The name of the profile "
       "is defined and scoped by its authoring organization.")]
class CIM_RegisteredProfile : CIM_ManagedElement { 

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority.  (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness, <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the organizational entity and SHOULD "
          "not be re-used to identify different underlying "
          "(real-world) elements.  If the above 'preferred' algorithm "
          "is not used, the defining entity MUST assure that the "
          "resultant InstanceID is not re-used across any InstanceIDs "
          "produced by this or other providers for this instance's "
          "NameSpace.  \n"
          "For DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]
  string InstanceID;

      [Required, Description (
          "The organization that defines this profile."), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
          "11", "12", "13", "14", "15", "16", "17", "18", "19" }, 
       Values { "Other", "DMTF", "CompTIA",
          "Consortium for Service Innovation", "FAST", "GGF", "INTAP",
          "itSMF", "NAC", 
          //10 
          "Northwest Energy Efficiency Alliance", "SNIA", "TM Forum",
          "The Open Group", "ANSI", "IEEE", "IETF", "INCITS", "ISO",
          "W3C" }, 
       ModelCorrespondence { 
          "CIM_RegisteredProfile.OtherRegisteredOrganization" }] 
    uint16 RegisteredOrganization; 

      [Description (
          "A free-form string providing a description of the "
          "organization when 1, \"Other\", is specified for the "
          "RegisteredOrganization."), 
       MaxLen ( 256 ), 
       ModelCorrespondence { 
          "CIM_RegisteredProfile.RegisteredOrganization" }] 
    string OtherRegisteredOrganization; 

      [Required, Description (
          "The name of this registered profile.  Since multiple "
          "versions can exist for the same RegisteredName, the "
          "combination of RegisteredName, RegisteredOrganization, and "
          "RegisteredVersion MUST uniquely identify the registered "
          "profile within the scope of the organization."), 
       MaxLen ( 256 )]
    string RegisteredName; 

      [Required, Description (
          "The version of this profile.  The string representing the "
          "version MUST be in the form: \n"
          "M + \".\" + N + \".\" + U \n"
          "Where: \n"
          "M - The major version (in numeric form) describing the "
          "profile's creation or last modification.  \n"
          "N - The minor version (in numeric form) describing the "
          "profile's creation or last modification.  \n"
          "U - The update (e.g.  errata, patch, ..., in numeric form) "
          "describing the profile's creation or last modification.")]
    string RegisteredVersion; 

      [Required, Description (
          "This property signifies the advertisement for the profile "
          "information.  It is used by the advertising services of the "
          "WBEM infrastructure to determine what should be advertised, "
          "via what mechanisms.  The property is an array so that the "
          "profile MAY be advertised using several mechanisms.  Note: "
          "If this property is null/uninitialized, this is equivalent "
          "to specifying the value 2, \"Not Advertised\"."), 
       ValueMap { "1", "2", "3" }, 
       Values { "Other", "Not Advertised", "SLP" },
          ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_RegisteredProfile.AdvertiseTypeDescriptions" }]
    uint16 AdvertiseTypes[];

      [Description (
          "A free-form string providing additional information related "
          "to the AdvertiseType.  A description MUST be provided when "
          "the AdvertiseType is 1, \"Other\".  An entry in this array "
          "corresponds to the entry in the AdvertiseTypes array at the "
          "same index.  It is not expected that additional "
          "descriptions are needed if the Type is set to \"Not "
          "Advertised\" or \"SLP\".  However, as the SLP template "
          "expands, or as other advertisement mechanisms are defined, "
          "support for additional descriptions may be needed.  This "
          "array is defined to support this."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RegisteredProfile.AdvertiseTypes" }] 
    string AdvertiseTypeDescriptions[]; 
}; 


// ===================================================================
// Location
// ===================================================================
   [Version ( "2.6.0" ), Description (
       "The Location class specifies the position and address of a "
       "PhysicalElement.")]
class CIM_Location : CIM_ManagedElement {
      
    [Key, MaxLen (256), 
        Description (
            "Name is a free-form string defining a label for the "
            "Location. It is a part of the key for the object.") ]
    string Name;
    
    [Key, MaxLen (256), Description (
        "Position is a free-form string indicating the placement "
        "of a PhysicalElement.  It can specify slot information on "
        "a HostingBoard, mounting site in a Cabinet, or latitude and "
        "longitude information, for example, from a GPS. It is "
        "part of the key of the Location object.") ]
    string PhysicalPosition;
    
    [MaxLen (1024), Description (
        "Address is a free-form string indicating a street, building "
        "or other type of address for the PhysicalElement's "
        "Location.") ]
    string Address;
};


// ===================================================================
// StatisticalData
// ===================================================================
   [Abstract, Version ( "2.8.0" ), Description (
       "CIM_StatisticalData is a root class for any arbitrary "
       "collection of statistical data and/or metrics applicable to "
       "one or more ManagedElements.  These statistics MUST represent "
       "the most recent observations and MUST NOT be provided if "
       "irrelevant or stale.  Note that this class uses a simplified "
       "naming/identity algorithm as compared to "
       "CIM_StatisticalInformation.")] 
class CIM_StatisticalData : CIM_ManagedElement { 

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nFor DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]        
    string InstanceID;

    [Override ("ElementName"), Required, Description (
        "The user friendly name for this instance of StatisticalData. "
        "In addition, the user friendly name can be used as a "
        "index property for a search of query.  (Note:  Name "
        "does not have to be unique within a namespace.)") ]
    string ElementName;
    
      [Description (
          "The time, relative to managed element where the statistic "
          "was collected, when the first measurement was taken.  If "
          "the statistic is reset, the StartStatisticTime is the time "
          "when the reset was performed.")]
   datetime StartStatisticTime;

      [Description (
          "The time the most recent measurement was taken, relative to "
          "the managed element where the statistic was collected.")]
   datetime StatisticTime;

      [Description (
          "Some statistics are sampled at consistent time intervals.  "
          "This property provides the sample interval so that client "
          "applications can determine the minimum time that new "
          "statistics should be pulled.  If the statistics are not "
          "sampled at consistent time intervals, this property must be "
          "set to a zero time interval.")]
   datetime SampleInterval = "00000000000000.000000:000";

      [Description (
          "Method to reset one or more of the instance's statistics.  "
          "The method takes one parameter as input - an array of "
          "strings indicating which statistics to reset.  If all the "
          "statistics in the instance should be reset, the first "
          "element of the array MUST be set to \"All\" or \"ALL\".  If "
          "one or more individual statistics should be reset, the "
          "corresponding property names are entered into the elements "
          "of the array.  \n"
          "The method returns 0 if successful, 1 if not supported, and "
          "any other value if an error occurred.  A method is "
          "specified so that the StatisticalInformation's provider/ "
          "instrumentation, which calculates the statistics, can reset "
          "its internal processing, counters, etc.  \n"
          "In a subclass, the set of possible return codes could be "
          "specified, using a ValueMap qualifier on the method.  The "
          "strings to which the ValueMap contents are 'translated' may "
          "also be specified in the subclass as a Values array "
          "qualifier.")]
    uint32 ResetSelectedStats ( 
     [IN, Description (
	 "Array of strings indicating which statistics to reset.")]
      string SelectedStatistics[]);
};


// ===================================================================
// MediaAccessStatistics
// ===================================================================
//[Experimental, Description ("The expected CIM-superclass for statistical data") ]
//class CIM_MediaAccessStatistics : CIM_StatisticalData
//{
//  [Experimental, Description ("...")] 
//  datetime StartStatisticsTime;

//  [Experimental, Description ("...")] 
//  datetime StatisticsTime;

//  [Experimental, Description ("...")] 
//  datetime SampleInterval = "00000000000000.000000:000";
//};


// ===================================================================
// Namespace
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "Namespace provides a domain (in other words, a container), in "
       "which the instances [of a class] are guaranteed to be unique "
       "per the KEY qualifier definitions.  It is named relative to "
       "the CIM_ObjectManager implementation that provides such a "
       "domain.")]
class CIM_Namespace : CIM_ManagedElement {
        
      [Key, Propagated ( "CIM_ObjectManager.SystemCreationClassName" ), 
       Description (
          "The scoping System's CreationClassName."), 
       MaxLen ( 256 )]
   string SystemCreationClassName;

      [Key, Propagated ( "CIM_ObjectManager.SystemName" ), 
       Description (
          "The scoping System's Name."), 
       MaxLen ( 256 )]
   string SystemName;

      [Key, Propagated ( "CIM_ObjectManager.CreationClassName" ), 
       Description (
          "The scoping ObjectManager's CreationClassName."), 
       MaxLen ( 256 )]
   string ObjectManagerCreationClassName;

      [Key, Propagated ( "CIM_ObjectManager.Name" ), Description (
          "The scoping ObjectManager's Name."), 
       MaxLen ( 256 )]
   string ObjectManagerName;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance.  When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Description (
          "A string to uniquely identify the Namespace within the "
          "ObjectManager."), 
       MaxLen ( 256 )]
   string Name;

      [Deprecated { "CIM_Namespace.ClassType" }, Required, Write, 
       Description (
          "Enumeration indicating the organization/schema of the "
          "Namespace's objects.  For example, they may be instances of "
          "classes of a specific CIM version."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "200", "201", "202" }, 
       Values { "Unknown", "Other", "CIM 1.0", "CIM 2.0", "CIM 2.1",
          "CIM 2.2", "CIM 2.3", "CIM 2.4", "CIM 2.5", "CIM 2.6",
          "CIM 2.7", "CIM 2.8", "DMI Recast", "SNMP Recast",
          "CMIP Recast" }, 
       ModelCorrespondence { "CIM_Namespace.DescriptionOfClassInfo" }]
   uint16 ClassInfo;

      [Deprecated { "CIM_Namespace.DescriptionOfClassType" }, Write, 
       Description (
          "A string providing more detail (beyond the general "
          "classification in ClassInfo) for the object hierarchy of "
          "the Namespace."), 
       ModelCorrespondence { "CIM_Namespace.ClassInfo" }]
   string DescriptionOfClassInfo;
   
   
      [Write, Description (
          "Enumeration indicating the schema of the Namespace's "
          "objects.  For example, they may be instances of classes of "
          "a specific CIM version or a mapping from another standard, "
          "such as SNMP.  If 'Other' is selected, the "
          "DescriptionOfClassType property MUST be populated."), 
       ValueMap { "0", "1", "2", "200", "201", "202" }, 
       Values { "Unknown", "Other", "CIM", "DMI Recast", "SNMP Recast",
          "CMIP Recast" }, 
       ModelCorrespondence { "CIM_Namespace.DescriptionOfClassType",
          "CIM_Namespace.ClassTypeVersion" }]
   uint16 ClassType;

      [Write, Description (
          "The version of the objects in this namespace.  The string "
          "representing the version MUST be in the form: \n"
          "M + \".\" + N + \".\" + U \n"
          "Where: \n"
          "M - The major version (in numeric form) \n"
          "N - The minor version (in numeric form) \n"
          "U - The update (e.g.  errata, patch, ..., in numeric form)"), 
       ModelCorrespondence { "CIM_Namespace.DescriptionOfClassType",
          "CIM_Namespace.ClassType" }]
   string ClassTypeVersion;

      [Write, Description (
          "A string providing more detail (beyond the general "
          "classification in ClassInfo) for the object hierarchy of "
          "the Namespace."), 
       ModelCorrespondence { "CIM_Namespace.ClassType",
          "CIM_Namespace.ClassTypeVersion" }]
   string DescriptionOfClassType;
};


// ===================================================================
// Setting
// ===================================================================
   [Abstract, Version ( "2.7.0" ), Description (
       "The Setting class represents configuration-related and "
       "operational parameters for one or more "
       "ManagedSystemElement(s).  An Element 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.  \n"
       "Note that the CIM_SettingData class is very similar to "
       "CIM_Setting, yet both classes are present in the model.  This "
       "is because many implementations have successfully used "
       "CIM_Setting.  However, issues have arisen that could not be "
       "resolved without defining a new class.  Therefore, until a new "
       "major release occurs, both classes will exist in the model.  "
       "Refer to the Core White Paper for additional information.")]
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, Description (
             "The Managed SystemElement that is being verified.")]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      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, Description (
             "The ManagedSystem Element to which the Setting is being "
             "applied.")]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      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, Description (
             "The Collection of Managed SystemElements that is being "
             "verified.")]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      datetime MustBeCompletedBy, 
         [IN ( false ), OUT, Description (
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting can NOT be "
             "applied.")]
      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, Description (
             "The Collection of Managed SystemElements to be applied.")]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "TRUE means to continue processing on encountering an "
             "error.")]
      boolean ContinueOnError, 
         [IN, Description (
             "The required completion time for the method.")]
      datetime MustBeCompletedBy, 
         [IN ( false ), OUT, Description (
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting was NOT be "
             "applied.")]
      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, Description (
             "The ManagedSystem Element for which the Setting is being "
             "verified.")]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      datetime MustBeCompletedBy, 
         [IN, Description (
             "A list of the property names whose values will be "
             "verified.")]
      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, Description (
             "The ManagedSystem Element to which the Setting is being "
             "applied.")]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      datetime MustBeCompletedBy, 
         [IN, Description (
             "A list of the property names whose values will be "
             "applied.")]
      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, Description (
             "The Collection of Managed SystemElements for which the "
             "setting is being verified.")]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description (
             "TimeToApply can be either a specific time or a time "
             "interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "The required completion time for the method.")]
      datetime MustBeCompletedBy, 
         [IN, Description (
             "A list of the property names whose values will be "
             "verified.")]
      string PropertiesToApply[], 
         [IN ( false ), OUT, Description (
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting can NOT be "
             "applied.")]
      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, Description (
             "The Collection of Elements to which the Setting is being "
             "applied.")]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description (
             "A specific time or a time interval.")]
      datetime TimeToApply, 
         [IN, Description (
             "TRUE means to continue processing on encountering an "
             "error.")]
      boolean ContinueOnError, 
         [IN, Description (
             "This parameter indicates the required completion time "
             "for the method.")]
      datetime MustBeCompletedBy, 
         [IN, Description (
             "A list of the property names whose values will be "
             "verified.")]
      string PropertiesToApply[], 
         [IN ( false ), OUT, Description (
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting can NOT be "
             "applied.")]
      string CanNotApply[]);  
};


// ===================================================================
// TimeZone
// ===================================================================
[Version("2.6.0"), Description (
    "The TimeZone class is a set of properties defining a particular "
    "time zone. These properties include the concept of daylight "
    "saving time.") ]
class CIM_TimeZone : CIM_Setting {
    [Key, Description (
        "Time zone identifier. The Id MAY be expressed in the form "
        "'area name/city name' (e.g., \"America/New_York\"), or as "
        "a time zone name (for example, EST or EDT).") ]
    string TimeZoneID;
    
    [Key, Description (
        "The date and time at which this time zone definition "
        "takes effect. The value is specified in UTC.") ]
    datetime TimeZoneStartDate;
    
    [Description (
        "Full name of the 'standard' time zone (e.g., \"U.S. Eastern "
        "Standard Time\"), suitable for presentation to the user "
        "in the default locale."),
        ModelCorrespondence {"CIM_TimeZone.StandardCaption"} ]
    string StandardName;
    
    [Description (
        "Short name of the 'standard' time zone (e.g., \"EST\"), "
        "suitable for presentation to the user in the default locale. "
        "Note that a specific StandardCaption property is defined, "
        "instead of using the inherited Caption. This is done to force "
        "consistent property naming for the StandardXXX and "
        "DaylightXXX properties."),
        ModelCorrespondence {"CIM_TimeZone.StandardName"} ]
    string StandardCaption;
    
    [Description (
        "The number of minutes by which this 'standard' time "
        "differs from UTC. For example, U.S. EST differs "
        "from UTC by -5.0 hours or -300 minutes, whereas "
        "Australia Adelaide Standard Time differs by 9.5 hours "
        "or 570 minutes."), 
        Units ("Minutes") ]
    sint32 StandardOffset;
    
      [Description (
          "The month in which daylight saving time ends (and "
          "'standard' time begins).  Specify 0 for January, 1 for "
          "February, and so on."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "January", "February", "March", "April", "May", "June",
          "July", "August", "September", "October", "November",
          "December" }, 
       ModelCorrespondence { "CIM_TimeZone.StandardDay" }]
    uint8 StandardMonth;
    
      [Description (
          "There are two different interpretations for this property, "
          "depending on the value of StandardDayOfWeek.  In one case, "
          "StandardDay defines the day-in-month on which daylight "
          "saving time ends.  This interpretation is used when the "
          "StandardDayOfWeek is 0.  A positive or negative integer is "
          "specified to indicate whether the StandardDay should be "
          "calculated from the beginning or the end of the month.  For "
          "example, 5 indicates the fifth day in the StandardMonth and "
          "-1 indicates the last day in the StandardMonth.  \n"
          "\n"
          "When StandardDayOfWeek is not 0, StandardDay is the day- "
          "in-month on which daylight saving time ends, defined in "
          "conjunction with StandardDayOfWeek.  For example, if "
          "StandardDay is 15 and StandardDayOfWeek is Saturday, then "
          "daylight saving time ends on the first Saturday on or after "
          "the 15th day in the StandardMonth (i.e., the third Saturday "
          "in the month).  If StandardDay is 20 and StandardDayOfWeek "
          "is -Saturday, then this indicates the first Saturday on or "
          "before the 20th day in the StandardMonth.  If StandardDay "
          "is -1 and StandardDayOfWeek is -Sunday, then this indicates "
          "the last Sunday in the StandardMonth."), 
       MinValue ( -31 ), MaxValue ( 31 ), 
       ModelCorrespondence { "CIM_TimeZone.StandardDayOfWeek" }]
    sint8 StandardDay;
     
      [Description (
          "Positive or negative integer used in conjunction with "
          "StandardDay to indicate the day of the week on which "
          "daylight saving time ends (and 'standard' time begins).  "
          "StandardDayOfWeek is set to 0 to indicate an exact day of "
          "the month, such as March 1.  A positive integer "
          "(representing Sunday, Monday, ..., Saturday) means that the "
          "day of week is found on or after the specified "
          "StandardDay.  A negative integer (representing -Sunday, "
          "-Monday, ..., -Saturday) means that the day of week is "
          "found on or before the StandardDay."), 
       ValueMap { "-7", "-6", "-5", "-4", "-3", "-2", "-1", "0", "1",
          "2", "3", "4", "5", "6", "7" }, 
       Values { "-Saturday", "-Friday", "-Thursday", "-Wednesday",
          "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
          "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
          "Friday", "Saturday" }, 
       ModelCorrespondence { "CIM_TimeZone.StandardDay" }]
   sint8 StandardDayOfWeek;
    
    [Description (
        "The time interval after midnight when daylight "
        "saving time ends. For example, \n"
        "   00000000020000.000000:000 \n"
        "indicates that daylight saving time ends at two o'clock, "
        "local time (usually, daylight saving time).") ]
    datetime StandardStartInterval;
    
      [Description (
          "Full name of the 'daylight' time zone (e.g., \"U.S.  "
          "Eastern Daylight Saving Time\"), suitable for presentation "
          "to the user in the default locale."), 
       ModelCorrespondence { "CIM_TimeZone.DaylightCaption" }]
   string DaylightName;
    
    [Description (
        "Short name of the 'daylight' time zone (e.g., \"EDT\"), "
        "suitable for presentation to the user in the default locale. "
        "Note that a specific DaylightCaption property is defined, "
        "instead of using the inherited Caption. This is done to force "
        "consistent property naming for the StandardXXX and "
        "DaylightXXX properties."),
        ModelCorrespondence {"CIM_TimeZone.DaylightName"} ]
    string DaylightCaption;
    
      [Description (
          "The number of minutes by which this daylight saving time "
          "differs from UTC.  For example, U.S.  EDT differs from UTC "
          "by -4.0 hours or -240 minutes, whereas Australia Adelaide "
          "Daylight Time differs by 10.5 hours or 630 minutes."), 
       Units ( "Minutes" )]
   sint32 DaylightOffset;

      [Description (
          "The month in which daylight saving time starts.  Specify 0 "
          "for January, 1 for February, and so on."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "January", "February", "March", "April", "May", "June",
          "July", "August", "September", "October", "November",
          "December" }, 
       ModelCorrespondence { "CIM_TimeZone.DaylightDay" }]
   uint8 DaylightMonth;

      [Description (
          "There are two different interpretations for this property, "
          "depending on the value of DaylightDayOfWeek.  In one case, "
          "DaylightDay defines the day-in-month on which daylight "
          "saving time starts.  This interpretation is used when the "
          "DaylightDayOfWeek is 0.  A positive or negative integer is "
          "specified to indicate whether the DaylightDay should be "
          "calculated from the beginning or the end of the month.  For "
          "example, 5 indicates the fifth day in the DaylightMonth and "
          "-1 indicates the last day in the DaylightMonth.  \n"
          "\n"
          "When DaylightDayOfWeek is not 0, DaylightDay is the day- "
          "in-month on which daylight saving time starts, defined in "
          "conjunction with DaylightDayOfWeek.  For example, if "
          "DaylightDay is 15 and DaylightDayOfWeek is Saturday, then "
          "daylight saving time starts on the first Saturday on or "
          "after the 15th day in the DaylightMonth (i.e., the third "
          "Saturday in the month).  If DaylightDay is 20 and "
          "DaylightDayOfWeek is -Saturday, then this indicates the "
          "first Saturday on or before the 20th day in the "
          "DaylightMonth.  If DaylightDay is -1 and DaylightDayOfWeek "
          "is -Sunday, then this indicates the last Sunday in the "
          "month."), 
       MinValue ( -31 ), MaxValue ( 31 ), 
       ModelCorrespondence { "CIM_TimeZone.DaylightDayOfWeek" }]
   sint8 DaylightDay;
    
      [Description (
          "Positive or negative integer used in conjunction with "
          "DaylightDay to indicate the day of the week on which "
          "daylight saving time starts.  Set DaylightDayOfWeek to 0 to "
          "indicate an exact day of month, such as March 1.  Positive "
          "integer (Sunday, Monday, ..., Saturday) means that the day "
          "of week is found on or after DaylightDay.  Negative integer "
          "(-Sunday, -Monday, ..., -Saturday) means that the day of "
          "week is found on or before DaylightDay."), 
       ValueMap { "-7", "-6", "-5", "-4", "-3", "-2", "-1", "0", "1",
          "2", "3", "4", "5", "6", "7" }, 
       Values { "-Saturday", "-Friday", "-Thursday", "-Wednesday",
          "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
          "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
          "Friday", "Saturday" }, 
       ModelCorrespondence { "CIM_TimeZone.DaylightDay" }]
   sint8 DaylightDayOfWeek;

      [Description (
          "The time interval after midnight when daylight saving time "
          "starts.  For example, \n"
          "00000000020000.000000:000 \n"
          "indicates that daylight saving time starts at two o'clock, "
          "local time (usually, standard time).")]
   datetime DaylightStartInterval;
};  


// ===================================================================
// IndicationFilter
// ===================================================================
   [Version ( "2.6.0"), Description (
       "CIM_IndicationFilter defines the criteria for generating an "
       "Indication and what data should be returned in the "
       "Indication.  It is derived from CIM_ManagedElement to allow "
       "modeling the dependency of the filter on a specific service."),
       CreateRole("Administrator"), DeleteRole("Administrator")]

class CIM_IndicationFilter: CIM_ManagedElement {

      [Key, Description (
          "A System's CreationClassName.  The Filter is defined in the "
          "context of a CIM_System, where it is hosted or to which it "
          "applies.  In a future release, a weak relationship will be "
          "explicitly added to the model.  This is not done now to "
          "allow further refinement of the Filter definition and its "
          "inheritance tree.  Keys are defined now to allow the class "
          "to be instantiated."), 
       MaxLen ( 256) ]
   string SystemCreationClassName;

      [Key, Description (
          "A System's Name.  The Filter is defined in the context of a "
          "CIM_System, where it is hosted or to which it applies.  In "
          "a future release, a weak relationship will be explicitly "
          "added to the model.  This is not done now to allow further "
          "refinement of the Filter definition and its inheritance "
          "tree.  Keys are defined now to allow the class to be "
          "instantiated."), 
       MaxLen ( 256) ]
   string SystemName;

      [Key, Description (
          "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, it allows all instances of this "
          "class and its subclasses to be uniquely identified."), 
       MaxLen ( 256) ]
   string CreationClassName;

      [Key, Description (
          "The name of the filter.") ]
   string Name;

      [Description (
          "The path to a local namespace where the Indications "
          "originate.  If NULL, the namespace of the Filter "
          "registration is assumed.") ]
   string SourceNamespace;

      [Required, Description (
          "A query expression that defines the condition(s) under "
          "which Indications will be generated.  For some Indication "
          "classes, the query expression may also define the instance "
          "properties to be copied to the CIM_InstIndication's "
          "SourceInstance and PreviousInstance properties.  Query "
          "language semantics include projection (e.g., Select), range "
          "(e.g., From) and predicate (e.g., Where)."), 
       ModelCorrespondence { "CIM_IndicationFilter.QueryLanguage"} ]
   string Query;

      [Required, Description (
          "The language in which the query is expressed.") ]
   string QueryLanguage;
};


// ==================================================================
// ListenerDestination
// ==================================================================
   [Abstract, Version ("2.8.0"), Description (
       "The description of a CIM Listener destination.  A CIM_Listener "
       "is an entity capable of receiving CIM Export Messages (e.g., "
       "Indications or responses to an asynchronous CIM Operation).") ]
class CIM_ListenerDestination: CIM_ManagedElement {

      [Key, Description (
          "A System's CreationClassName.  A CIM Listener destination "
          "is defined in context of a CIM_System (e.g., the sending "
          "system."), 
       MaxLen ( 256) ]
   string SystemCreationClassName;

      [Key, Description (
          "A System's Name.  A CIM Listener destination is defined in "
          "context of a CIM_System (e.g., the sending system."), 
       MaxLen ( 256) ]
   string SystemName;

      [Key, Description (
          "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, it allows all instances of this "
          "class and its subclasses to be uniquely identified."), 
       MaxLen ( 256) ]
   string CreationClassName;

      [Key, Description (
          "Indicates the name of the CIM Listener destination."), 
       MaxLen ( 256) ]
   string Name;

      [Description (
          "Describes the Persistence Type of the destination defined "
          "by this instance.  If the value of PersistenceType is not "
          "specified, the value of PersistenceType MUST be treated as "
          "2 (\"Permanent\").  A value of 2 (\"Permanent\") declares "
          "that the destination is always expected to be available "
          "(e.g., system log file).  Inability to access this "
          "destination MUST be treated as an error condition.  A value "
          "of 3 (\"Transient\") indicates that the destination is "
          "short-lived.  Inability to access the destination MAY be "
          "treated as a normal termination condition.  Subscriptions "
          "with \"Transient\" destinations MAY be deleted when the "
          "destination terminates or is no longer available."), 
       ValueMap { "1", "2", "3"}, 
       Values { "Other", "Permanent", "Transient"}, 
       ModelCorrespondence { 
          "CIM_ListenerDestination.OtherPersistenceType"} ]
   uint16 PersistenceType;

      [Description (
          "A string describing (\"Other\") values for "
          "PersistenceType.  This value MUST be set to a non NULL "
          "value when the PersistenceType is 1 (\"Other\").  For all "
          "other values of PersistenceType, the value of "
          "OtherPersistenceType MUST be NULL."), 
       ModelCorrespondence { "CIM_ListenerDestination.PersistenceType"} ]
   string OtherPersistenceType;
};

// ====================================================================
// CIM_ListenerDestinationCIMXML
// ====================================================================

   [Version ( "2.8.0" ), Description (
       "CIM_ListenerDestinationCIMXML describes the destination for "
       "CIM Export Messages to be delivered via CIM-XML."),
       CreateRole("Administrator"), DeleteRole("Administrator")]
       
class CIM_ListenerDestinationCIMXML : CIM_ListenerDestination {

      [Required, Description (
          "The destination URL to which CIM-XML Export Messages are to "
          "be delivered.The scheme prefix MUST be consistent with the "
          "DMTF CIM-XML specifications.If a scheme prefix is not "
          "specified, the scheme \"http:\" MUST be assumed.")]
   string Destination;
};



// ===================================================================
// IndicationHandler
// ===================================================================
   [Deprecated { "CIM_ListenerDestination"}, Abstract,
       Version ( "2.8.0"), Description (
       "CIM_IndicationHandler is an abstract superclass describing how "
       "an Indication is to be processd/delivered/'handled'.  This may "
       "define a destination and protocol for delivering Indications, "
       "or it may define a process to invoke.  This class is derived "
       "from CIM_ManagedElement to allow modeling the dependency of "
       "the Handler on a specific service.") ]
class CIM_IndicationHandler : CIM_ListenerDestination {

      [Deprecated {"No value"}, Description (
          "The name of the entity that created and/or maintains this "
          "Handler.") ]
   string Owner;
};

// ===================================================================
// 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;
};   


// ===================================================================
// ManagesAccount
// ===================================================================
   [Association, Version ( "2.6.0"), Description (
       "This relationship associates the AccountManagement security "
       "service to the Accounts for which it is responsible.") ]
class CIM_ManagesAccount : CIM_Dependency {

      [Override ( "Antecedent"), Description (
          "The account management service.") ]
   CIM_AccountManagementService REF Antecedent;

      [Override ( "Dependent"), Description (
          "An account managed by the service.") ]
   CIM_Account REF Dependent;
};


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

      [Deprecated { "CIM_ServiceAvailableToElement.ServiceProvided" },
       Override ( "Antecedent" ), Description (
          "The Service provided.")]
   CIM_Service REF Antecedent;

      [Deprecated { "CIM_ServiceAvailableToElement.UserOfService" },
       Override ( "Dependent" ), Description (
          "The ManagedElement dependent on the Service.")]
   CIM_ManagedElement REF Dependent;
};


// ===================================================================
// SecurityServiceForSystem
// ===================================================================
   [Association, Version ( "2.6.0"), Description (
       "The CIM_SecurityServiceForSystem provides the association "
       "between a System and a SecurityService that provides services "
       "for that system.  Examining the SecurityServiceForSystem class "
       "definition, note that its superclass ProvidesServiceToElement "
       "is deprecated.  Unfortunately, ProvidesServiceToElement cannot "
       "be removed from the object hierarchy without a major Schema "
       "release.  When/if this occurs, the ProvidesServiceToElement "
       "superclass will be removed, and SecurityServiceForSystem will "
       "subclass from CIM_Dependency directly.") ]
class CIM_SecurityServiceForSystem : CIM_ProvidesServiceToElement {

      [Override ( "Antecedent"), Description (
          "The SecurityService that provides services for the system.") ]
   CIM_SecurityService REF Antecedent;

      [Override ( "Dependent"), Description (
          "The system that is dependent on the security service.") ]
   CIM_System REF Dependent;
};


// ===================================================================
// ManagesAccountOnSystem
// ===================================================================
   [Association, Version ( "2.6.0"), Description (
       "The CIM_ManagesAccountOnSystem provides the association "
       "between a System and the AccountManagementService that manages "
       "accounts for that system.") ]
class CIM_ManagesAccountOnSystem : CIM_SecurityServiceForSystem {

      [Override ( "Antecedent"), Description (
          "An AccountManagementService that manages accounts for the "
          "system.") ]
   CIM_AccountManagementService REF Antecedent;

      [Override ( "Dependent"), Description (
          "The system that is dependent on the "
          "AccountManagementService.") ]
   CIM_System REF Dependent;
};


// ===================================================================
// AllocatedFromStoragePool
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "AllocatedFromStoragePool is an association describing how "
       "LogicalElements are allocated from underlying StoragePools.  "
       "These elements typically would be subclasses of StorageExtents "
       "or StoragePools.")]
class CIM_AllocatedFromStoragePool : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The StoragePool.")]
   CIM_StoragePool REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The subsidiary element.")]
   CIM_LogicalElement REF Dependent;

      [Required, Description (
          "Space consumed from this Pool, in bytes.  This value MUST "
          "be maintained so that, relative to the Antecedent "
          "StoragePool, it is possible to compute TotalManagedSpace as "
          "StoragePool.RemainingManagedSpace plus the sum of "
          "SpaceConsumed from all of the AllocatedFromStoragePool "
          "references from the antecedent StoragePool."), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace",
          "CIM_StoragePool.RemainingManagedSpace" }]
   uint64 SpaceConsumed;
};


// ===================================================================
// ProtocolControllerForDevice
// ===================================================================
   [Association, Abstract, Version ( "2.8.0" ), Description (
       "This association indicates a subclass of LogicalDevice (for "
       "example a Storage Volume) is connected through a specific "
       "ProtocolController.  In many situations (for example storage "
       "LUN masking), there may be many of these associations used to "
       "relate to different objects.  Therefore subclasses have been "
       "defined to optimize enumeration of the associations.")]
class CIM_ProtocolControllerForDevice : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The ProtocolController.")]
   CIM_ProtocolController REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The controlled Device.")]
   CIM_LogicalDevice REF Dependent;

      [Description (
          "Address of the associated Device in the context of the "
          "Antecedent Controller.")]
   string DeviceNumber;

      [Description (
          "This property describes the priority given to accesses of "
          "the device through this Controller.  The highest priority "
          "path will have the lowest value for this parameter.")]
   uint16 AccessPriority;

      [Description (
          "The State property indicates whether the Controller is "
          "actively commanding or accessing the device (value=2) or "
          "not (value=3).  Also, the value, \"Unknown\" (0), can be "
          "defined.  This information is necessary when a "
          "LogicalDevice can be commanded by, or accessed through, "
          "multiple ProtocolControllers."), 
       ValueMap { "0", "2", "3" }, 
       Values { "Unknown", "Active", "Inactive" }]
   uint16 AccessState;
};

// ===================================================================
// ProtocolControllerForUnit
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "This association is used to define a relationship between a "
       "ProtocolController and an exposed Logical Unit (for example a "
       "Storage Volume or a MediaAccessDevice such as a tape drive).  "
       "An example of the use of this association is SCSI, where it "
       "link the target controller and Logical Units.  This subclass "
       "is provided so that an enumeration of related controllers and "
       "units can be performed without retrieving any connected ports "
       "or other controllers.")]
class CIM_ProtocolControllerForUnit : CIM_ProtocolControllerForDevice {

      [Override ( "Antecedent" ), Description (
          "The ProtocolController.")]
   CIM_ProtocolController REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The logical unit (eg StorageVolume) 'behind' the "
          "ProtocolController.")]
   CIM_LogicalDevice REF Dependent;
};

// ===================================================================
// ProtocolControllerAccessesUnit
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "This association is used to define a relationship between a "
       "protocol controllers and a Logical Unit (for example a Storage "
       "Volume or Media Access Device) controlled by the controller.  "
       "This association is used instead of ProtocolControllerForUnit "
       "to indicate a 'controlled through' relationship rather than a "
       "'controlled by' one.  An example is SCSI where this "
       "association is used to indicate a target/initiator "
       "relationship.")]
class CIM_ProtocolControllerAccessesUnit : CIM_ProtocolControllerForDevice {

      [Override ( "Antecedent" ), Description (
          "The protocol controller.")]
   CIM_ProtocolController REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The logical unit (eg StorageVolume).")]
   CIM_LogicalDevice REF Dependent;

      [Description (
          "The number of the dependent's target protocol controller.  "
          "As an example, in SCSI this is the Target ID.")]
   string TargetControllerNumber;
};


// ===================================================================
// ProtocolControllerForPort
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "This association is used to define a relationship between a "
       "ProtocolController and a LogicalPort.  This subclass is "
       "provided so that an enumeration of related controllers and "
       "ports can be performed without retrieving any other "
       "controllers or connected units.")]
class CIM_ProtocolControllerForPort : CIM_ProtocolControllerForDevice {

      [Override ( "Antecedent" ), Description (
          "The ProtocolController.")]
   CIM_ProtocolController REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The LogicalPort 'behind' the ProtocolController.")]
   CIM_LogicalPort REF Dependent;
};


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

      [Override ( "Antecedent" ), Description (
          "Antecedent represents the independent object in this "
          "association.")]
   CIM_ManagedElement REF Antecedent;

      [Override ( "Dependent" ), Description (
          "Dependent represents the object dependent on the "
          "Antecedent.")]
   CIM_ManagedElement REF Dependent;
};


// ==================================================================
// HostedDependency
// ==================================================================
   [Association, Version ( "2.8.0" ), Description (
       "HostedDependency defines a ManagedElement in the context of "
       "another ManagedElement in which it resides.")]
class CIM_HostedDependency : CIM_Dependency {

      [Override ( "Antecedent" ), Max ( 1 ), Description (
          "The scoping ManagedElement.")]
   CIM_ManagedElement REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The hosted ManagedElement.")]
   CIM_ManagedElement REF Dependent;
};


// ===================================================================
// HostedService
// ===================================================================
   [Association, Version ( "2.8.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_HostedDependency {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 1 ), Description (
          "The hosting System.")]
   CIM_System REF Antecedent;

      [Override ( "Dependent" ), Weak, Description (
          "The Service hosted on the System.")]
   CIM_Service REF Dependent;
};



// ===================================================================
// HostedClusterService
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "HostedClusterService defines the hosting Cluster for a "
       "ClusteringService. Since this relationship is subclassed from "
       "HostedService, it inherits the scoping/naming scheme defined "
       "for Service - where a Service is weak to its hosting System. "
       "In this case, a ClusteringService must be weak to its hosting "
       "Cluster System.")]
class CIM_HostedClusterService : CIM_HostedService {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 1 ), Description (
          "The Cluster.")]
   CIM_Cluster REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The ClusteringService that is hosted on the Cluster.")]
   CIM_ClusteringService REF Dependent;
};


// ===================================================================
// SystemPackaging
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "Similar to the way that LogicalDevices are 'Realized' by "
       "PhysicalElements, Systems may be associated with specific "
       "packaging/PhysicalElements.  This association explicitly "
       "defines the relationship between a System and its packaging.")]
class CIM_SystemPackaging : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The PhysicalElement(s) that provide the packaging of a "
          "System.")]
   CIM_PhysicalElement REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The System whose packaging is described.")]
   CIM_System REF Dependent;
};


// ===================================================================
// ComputerSystemPackage
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "Similar to the way that LogicalDevices are 'Realized' by "
       "PhysicalElements, UnitaryComputerSystems are realized in one "
       "or more PhysicalPackages.  The ComputerSystemPackage "
       "association explicitly defines this relationship.")]
class CIM_ComputerSystemPackage : CIM_SystemPackaging {

      [Override ( "Antecedent" ), Description (
          "The PhysicalPackage(s) that realize a Unitary "
          "ComputerSystem.")]
   CIM_PhysicalPackage REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The UnitaryComputerSystem.")]
   CIM_ComputerSystem REF Dependent;

      [Description (
          "A Gloabally Unique Identifier for the System's Package.")]
   string PlatformGUID;
};


// ===================================================================
// HostedAccessPoint
// ===================================================================
   [Association, Version ( "2.8.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_HostedDependency {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 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;
};


// ===================================================================
// MediaPresent
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "Where a StorageExtent must be accessed through a MediaAccess "
       "Device, this relationship is described by the MediaPresent "
       "association."), 
    MappingStrings { "MIF.DMTF|Storage Devices|001.8" }]
class CIM_MediaPresent : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The MediaAccessDevice.")]
   CIM_MediaAccessDevice REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The StorageExtent accessed using the MediaAccessDevice.")]
   CIM_StorageExtent REF Dependent;

      [Description (
          "Boolean indicating that the accessed StorageExtent is fixed "
          "in the MediaAccessDevice and can not be ejected.")]
   boolean FixedMedia;
};


// ===================================================================
// 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;
};


// ===================================================================
// ReferencedProfile
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "A profile that is referenced by another RegisteredProfile.")]
class CIM_ReferencedProfile : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The RegisteredProfile that is referenced by the Dependent "
          "Profile.")]
   CIM_RegisteredProfile REF Antecedent;

      [Override ( "Dependent" ), Description (
          "A RegisteredProfile that references other profiles.")]
   CIM_RegisteredProfile REF Dependent;
};


// ===================================================================
// NamespaceInManager
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "NamespaceInManager is an association describing the Namespaces "
       "hosted by a CIM ObjectManager.")]
class CIM_NamespaceInManager : CIM_HostedDependency {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 1 ), Description (
          "The ObjectManager containing a Namespace.")]
   CIM_ObjectManager REF Antecedent;

      [Override ( "Dependent" ), Weak, Description (
          "The Namespace in an ObjectManager.")]
   CIM_Namespace 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;
};


// ===================================================================
// CommMechanismForManager
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "CommMechanismForManager is an association between an "
       "ObjectManager and an ObjectManagerCommunicationMechanism "
       "class.  The latter describes a possible encoding/protocol/ set "
       "of operations for accessing the referenced ObjectManager.")]
class CIM_CommMechanismForManager : CIM_ServiceAccessBySAP {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 1 ), Description (
          "The specific ObjectManager whose communication mechanism is "
          "described.")]
   CIM_ObjectManager REF Antecedent;

      [Override ( "Dependent" ), Min ( 1 ), Description (
          "The encoding/protocol/set of operations that may be used to "
          "communicate with the referenced ObjectManager.")]
   CIM_ObjectManagerCommunicationMechanism REF Dependent;
};


// ===================================================================
// ParticipatingCS
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "A Cluster is composed of two or more ComputerSystems, "
       "operating together.  A ComputerSystem may participate in "
       "multiple Clusters.  \n"
       "\n"
       "When first establishing or bringing up a Cluster, only one "
       "ComputerSystem may be defined as participating in it.  "
       "Therfore, the cardinality of the association for the "
       "ComputerSystem reference is Min (1).")]
class CIM_ParticipatingCS : CIM_Dependency {

      [Override ( "Antecedent" ), Min ( 1 ), Description (
          "The ComputerSystem which participates in the Cluster.")]
   CIM_ComputerSystem REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Cluster.")]
   CIM_Cluster REF Dependent;

      [Description (
          "StateOfNode indicates the condition of the participating "
          "ComputerSystem in the Cluster.  For example, one value is "
          "\"Joining\" (2)."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6" }, 
       Values { "Unknown", "Other", "Joining", "Paused", "Available",
          "Unavailable", "Degraded" }]
   uint16 StateOfNode;

      [Description (
          "RoleOfNode indicates whether the Cluster nodes are peers "
          "(value = 2), connected in a master-slave/primary- secondary "
          "relationship (values = 3 for primary, 4 for secondary), "
          "available in a standby configuration (5) or of some other "
          "(1) or unknown (0) relationship.  In a System/390 "
          "environment, the nodes are identified as \"Base Plex\" "
          "(value=6) or \"Enhanced Plex\" (value=7)."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7" }, 
       Values { "Unknown", "Other", "Peer", "Primary", "Secondary",
          "Standby", "Base Plex", "Enhanced Plex" }]
   uint16 RoleOfNode;
};


// ===================================================================
// DeviceConnection
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "The DeviceConnection relationship indicates that two or more "
       "Device are connected together.")]
class CIM_DeviceConnection : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "A LogicalDevice.")]
   CIM_LogicalDevice REF Antecedent;

      [Override ( "Dependent" ), Description (
          "A second LogicalDevice connected to the Antecedent Device.")]
   CIM_LogicalDevice REF Dependent;

      [Description (
          "When several bus and/or connection speeds are possible, the "
          "NegotiatedSpeed property defines the one in use between the "
          "Devices.  Speed is specified in bits per second.  If "
          "connection or bus speeds are not negotiated, or if this "
          "information is not available/important to Device "
          "management, the property should be set to 0."), 
       Units ( "Bits per Second" ), 
       MappingStrings { "MIF.DMTF|Bus Port Association|001.2" }]
   uint64 NegotiatedSpeed;

      [Description (
          "When several bus and/or connection data widths are "
          "possible, the NegotiatedDataWidth property defines the one "
          "in use between the Devices.  Data width is specified in "
          "bits.  If data width is not negotiated, or if this "
          "information is not available/important to Device "
          "management, the property should be set to 0."), 
       Units ( "Bits" ), 
       MappingStrings { "MIF.DMTF|Bus Port Association|001.3" }]
   uint32 NegotiatedDataWidth;
};


// ===================================================================
// ControlledBy
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "The ControlledBy relationship indicates which Devices are "
       "controlled by a CIM_Controller.")]
class CIM_ControlledBy : CIM_DeviceConnection {

      [Override ( "Antecedent" ), Description (
          "The Controller.")]
   CIM_Controller REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The controlled Device.")]
   CIM_LogicalDevice REF Dependent;

      [Description (
          "The State property indicates whether the Controller is "
          "actively commanding or accessing the Device (value=1) or "
          "not (value=2).  Also, the value, \"Unknown\" (0), can be "
          "defined.  This information is necessary when a "
          "LogicalDevice can be commanded by, or accessed through, "
          "multiple Controllers."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "Active", "Inactive" }]
   uint16 AccessState;

      [Description (
          "The time that the downstream Device was last reset by the "
          "Controller.")]
   datetime TimeOfDeviceReset;

      [Description (
          "Number of hard resets issued by the Controller.  A hard "
          "reset returns the Device to its initialization or 'boot-up' "
          "state.  All internal Device state information and data are "
          "lost."), 
       Counter]
   uint32 NumberOfHardResets;

      [Description (
          "Number of soft resets issued by the Controller.  A soft "
          "reset does not completely clear current Device state and/or "
          "data.  Exact semantics are dependent on the Device, and on "
          "the protocols and mechanisms used to communicate to it."), 
       Counter]
   uint32 NumberOfSoftResets;

      [Description (
          "Address of associated Device in context of the antecedent "
          "Controller.")]
   string DeviceNumber;

      [Description (
          "This property describes the accessibility of the device "
          "thru the antedecent controller."), 
       ValueMap { "2", "3", "4" }, 
       Values { "ReadWrite", "ReadOnly", "NoAccess" }]
   uint16 AccessMode;

      [Description (
          "The property describes the priority given to accesses of "
          "the device thru this controller.  The highest priority path "
          "will have the lowest value for this parameter.")]
   uint16 AccessPriority;
};


// ===================================================================
// BasedOn
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "BasedOn is an association describing how StorageExtents can be "
       "assembled from lower level Extents.  For example, "
       "ProtectedSpaceExtents are parts of PhysicalExtents, while "
       "VolumeSets are assembled from one or more Physical or "
       "ProtectedSpaceExtents.  As another example, CacheMemory can be "
       "defined independently and realized in a PhysicalElement or can "
       "be 'based on' Volatile or NonVolatileStorageExtents.")]
class CIM_BasedOn : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The lower level StorageExtent.")]
   CIM_StorageExtent REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The higher level StorageExtent.")]
   CIM_StorageExtent REF Dependent;

      [Description (
          "StartingAddress indicates where in lower level storage, the "
          "higher level Extent begins.")]
   uint64 StartingAddress;

      [Description (
          "EndingAddress indicates where in lower level storage, the "
          "higher level Extent ends.  This property is useful when "
          "mapping non-contiguous Extents into a higher level "
          "grouping.")]
   uint64 EndingAddress;

      [Description (
          "If there is an order to the BasedOn associations that "
          "describe how a higher level StorageExtent is assembled, the "
          "OrderIndex property indicates this.  When an order exists, "
          "the instances of BasedOn with the same Dependent value "
          "(i.e., the same higher level Extent) should place unique "
          "values in the OrderIndex property.  The lowest value "
          "implies the first member of the collection of lower level "
          "Extents, and increasing values imply successive members of "
          "the collection.  If there is no ordered relationship, a "
          "value of zero should be specified.  An example of the use "
          "of this property is to define a RAID-0 striped array of 3 "
          "disks.  The resultant RAID array is a StorageExtent that is "
          "dependent on (BasedOn) the StorageExtents that describe "
          "each of the 3 disks.  The OrderIndex of each BasedOn "
          "association from the disk Extents to the RAID array could "
          "be specified as 1, 2 and 3 to indicate the order in which "
          "the disk Extents are used to access the RAID data.")]
   uint16 OrderIndex;
};


// ===================================================================
// UseOfMessageLog
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "ManagedSystemElements may record their event, error or "
       "informational data within MessageLogs.  The use of a Log to "
       "hold a ManagedSystemElement's data is described by this "
       "association.  The type of Element data captured by the Log can "
       "be specified using the RecordedData string property.")]
class CIM_UseOfMessageLog : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The MessageLog.")]
   CIM_MessageLog REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The ManagedSystemElement whose information is recorded in "
          "the MessageLog.")]
   CIM_ManagedSystemElement REF Dependent;

      [Description (
          "A free-form string describing the use of the Log by the "
          "ManagedSystemElement.")]
   string RecordedData;
};


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

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

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


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

      [Aggregate, Override ( "GroupComponent" ), 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;
};


// ===================================================================
// AccountOnSystem
// ===================================================================
   [Association, Aggregation, Version ( "2.6.0"), Description (
       "A system (e.g., ApplicationSystem, ComputerSystem, "
       "AdminDomain) aggregates Accounts and scopes the uniqueness of "
       "the Account names (i.e., userids).") ]
class CIM_AccountOnSystem : CIM_SystemComponent {

      [Aggregate, Override ( "GroupComponent"), Min ( 1), Max ( 1), 
       Description (
          "The aggregating system also provides name scoping for the "
          "Account.") ]
   CIM_System REF GroupComponent;

      [Override ( "PartComponent"), Weak, Description (
          "The subordinate Account.") ]
   CIM_Account REF PartComponent;
};


// ===================================================================
// SystemDevice
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "LogicalDevices may be aggregated by a System.  This "
       "relationship is made explicit by the SystemDevice "
       "association.")]
class CIM_SystemDevice : CIM_SystemComponent {

      [Aggregate, Override ( "GroupComponent" ), Min ( 1 ), Max ( 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;
};

// ===================================================================
// HostedStoragePool
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "SystemStoragePool is a specialization of SystemComponent "
       "association that establishes that the StoragePool is defined "
       "in the context of the System.")]
class CIM_HostedStoragePool : CIM_SystemComponent {

      [Aggregate, Override ( "GroupComponent" ), Min ( 1 ), Max ( 1 ), 
       Description (
          "The parent system in the Association.")]
   CIM_System REF GroupComponent;

      [Override ( "PartComponent" ), Description (
          "The StoragePool that is a component of a System.")]
   CIM_StoragePool REF PartComponent;
};


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

      [Aggregate, Override ( "GroupComponent" ), Description (
          "The ComputerSystem that contains and/or aggregates other "
          "Systems.")]
   CIM_ComputerSystem REF GroupComponent;

      [Override ( "PartComponent" ), Description (
          "The contained (Sub)ComputerSystem.")]
   CIM_ComputerSystem REF PartComponent;
};


// ===================================================================
// ProductPhysicalComponent
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "Indicates that the referenced PhysicalElement is acquired as "
       "part of a Product.")]
class CIM_ProductPhysicalComponent : CIM_Component {

      [Override ( "GroupComponent" ), Max ( 1 ), Description (
          "The Product.")]
   CIM_Product REF GroupComponent;

      [Override ( "PartComponent" ), Description (
          "The PhysicalElement which is a part of the Product.")]
   CIM_PhysicalElement REF PartComponent;
};


// ===================================================================
// RedundancyComponent
// ===================================================================
   [Association, Aggregation, Version ( "2.7.1" ), Description (
       "A RedundancyGroup aggregates Managed System Elements and "
       "indicates that these elements, taken together, provide "
       "redundancy.  All elements aggregated in a RedundancyGroup "
       "should be instantiations of the same object class.")]
class CIM_RedundancyComponent : CIM_Component {

      [Aggregate, Override ( "GroupComponent" ), Description (
          "The RedundancyComponent association indicates that 'this "
          "set of fans' or 'these physical extents' participate in a "
          "single RedundancyGroup.")]
   CIM_RedundancyGroup REF GroupComponent;

      [Override ( "PartComponent" ), Description (
          "The component of the redundancy group.")]
   CIM_ManagedSystemElement REF PartComponent;
};


// ===================================================================
// StoragePoolComponent
// ===================================================================
    [Association, Aggregation, Description (
     "StoragePoolComponent is a specialization of the "
     "Component association that establishes 'part of' "
     "relationships between a StoragePool and the StorageExtents "
     "of which it is composed.") ] 
class CIM_StoragePoolComponent : CIM_Component
{
        [Override ("GroupComponent"), Aggregate, 
         Description ("The parent System in the Association.") ] 
    CIM_StoragePool REF GroupComponent;

        [Override ("PartComponent"), Description (
         "The child element that is a component of a System.") ] 
    CIM_StorageExtent REF PartComponent;
};


// ===================================================================
// LogicalIdentity
// ===================================================================
   [Association, Abstract, Version ( "2.7.0" ), Description (
       "CIM_LogicalIdentity is an abstract and generic association, "
       "indicating that two ManagedElements represent different "
       "aspects of the same underlying entity.  This relationship "
       "conveys what could be defined with multiple inheritance.  In "
       "most scenarios, the Identity relationship is determined by the "
       "equivalence of Keys or some other identifying properties of "
       "the related Elements.  \n"
       "\n"
       "One of the scenarios where this relationship is reasonable is "
       "to represent that a LogicalDevice is both a 'bus' entity and a "
       "'functional' entity.  For example, a Device could be both a "
       "USB (bus) and a Keyboard (functional) entity.")]
class CIM_LogicalIdentity {

      [Key, Description (
          "SystemElement represents one aspect of the Managed "
          "Element.  The use of 'System' in the role name does not "
          "limit the scope of the association.  The role name was "
          "defined in the original association, where the referenced "
          "elements were limited to LogicalElements.  Since that time, "
          "it has been found valuable to instantiate these types of "
          "relationships for ManagedElements, such as Collections.  "
          "So, the referenced elements of the association were "
          "redefined to be ManagedElements.  Unfortunately, the role "
          "name could not be changed without deprecating the entire "
          "association.  This was not deemed necessary just to correct "
          "the role name.")]
   CIM_ManagedElement REF SystemElement;

      [Key, Description (
          "SameElement represents an alternate aspect of the "
          "ManagedElement.")]
   CIM_ManagedElement REF SameElement;
};


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

      [Override ( "SystemElement" ), Description (
          "One aspect of the ManagedElement.  The use of 'System' in "
          "the name does not limit the scope of the association.  This "
          "is an artifact of the original definition of the "
          "association.")]
   CIM_ManagedElement REF SystemElement;

      [Override ( "SameElement" ), Description (
          "Another aspect of the ManagedElement.")]
   CIM_ManagedElement REF SameElement;
};


// ===================================================================
// ObjectManagerIsProvider
// ===================================================================
[Association, Version ("2.7.1000"), Experimental, Description (
    "This aassociation indicates that the referenced ObjectManager "
    "acts as a Provider for the CIM classes listed in the associated "
    "ProviderCapabilities.") ]
class CIM_ObjectManagerIsProvider : CIM_LogicalIdentity { 
 
    [Override ("SystemElement"), Max (1), Description (
        "SystemElement represents one aspect of the Logical"
        "Element.") ]
    CIM_ObjectManager ref SystemElement;
 
    [Override ("SameElement"), Description (
        "SameElement represents an alternate aspect of the "
        "System entity.") ]
    CIM_Provider ref SameElement;
};


// ===================================================================
// AuthorizedTarget
// ===================================================================
   [Association, Version ( "2.8.0"), Description (
       "CIM_AuthorizedTarget is an association used to tie an "
       "Identity's or Role's AuthorizedPrivileges to specific "
       "target resources.") ]
class CIM_AuthorizedTarget {

      [Key, Description (
          "The AuthorizedPrivilege affecting the target resource.") ]
   CIM_AuthorizedPrivilege REF Privilege;

      [Key, Description (
          "The target set of resources to which the AuthorizedPrivilege "
          "applies.") ]
   CIM_ManagedElement REF TargetElement;
};


// ===================================================================
// AuthorizedSubject
// ===================================================================
   [Association, Version ( "2.8.0"), Description (
       "CIM_AuthorizedSubject is an association used to tie specific "
       "AuthorizedPrivileges to specific subjects (i.e., Identities, "
       "Roles or Collections of these).  At this time, only Identities "
       "and Roles (or Collections of Identities and Roles) should be "
       "associated to AuthorizedPrivileges using this relationship. "
       "Note that any Privileges not explicitly granted to a subject, "
       "SHOULD be denied.") ]
class CIM_AuthorizedSubject {

      [Key, Description (
          "The AuthorizedPrivilege either granted or denied to an "
          "Identity, Role or Collection.  Whether the privilege is "
          "granted or denied is defined by the inherited property, "
          "CIM_Privilege.PrivilegeGranted.") ]
   CIM_AuthorizedPrivilege REF Privilege;

      [Key, Description (
          "The Subject for which AuthorizedPrivileges are granted or "
          "denied. Whether the privilege is granted or denied is "
          "defined by the property, CIM_Privilege.PrivilegeGranted.") ]
   CIM_ManagedElement REF PrivilegedElement;
};


// ===================================================================
// ElementCapabilities
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "ElementCapabilities represents the association between "
       "ManagedElements and their Capabilities.  Note that the "
       "cardinality of the ManagedElement reference is Min(1), "
       "Max(1).  This cardinality mandates the instantiation of the "
       "ElementCapabilities association for the referenced instance of "
       "Capabilities.  ElementCapabilities describes the existence "
       "requirements and context for the referenced instance of "
       "ManagedElement.  Specifically, the ManagedElement MUST exist "
       "and provides the context for the Capabilities.")]
class CIM_ElementCapabilities {

      [Key, Min ( 1 ), Max ( 1 ), Description (
          "The managed element.")]
   CIM_ManagedElement REF ManagedElement;

      [Key, Description (
          "The Capabilities object associated with the element.")]
   CIM_Capabilities REF Capabilities;
};


// ===================================================================
// ElementSettingData
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "ElementSettingData represents the association between "
       "ManagedElements and applicable setting data.  This association "
       "also describes whether this is a default or current setting.")]
class CIM_ElementSettingData {

      [Key, Description (
          "The managed element.")]
   CIM_ManagedElement REF ManagedElement;

      [Key, Description (
          "The SettingData object associated with the element.")]
   CIM_SettingData REF SettingData;

      [Description (
          "An enumerated integer indicating that the referenced "
          "setting is a default setting for the element, or that this "
          "information is unknown."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "Is Default", "Is Not Default" }]
   uint16 IsDefault;

      [Description (
          "An enumerated integer indicating that the referenced "
          "setting is currently being used in the operation of the "
          "element, or that this information is unknown."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "Is Current", "Is Not Current" }]
   uint16 IsCurrent;
};



// ===================================================================
// 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;
};


// ===================================================================
// ElementConformsToProfile
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "The CIM_ElementConformsToProfile association defines the "
       "RegisteredProfiles to which the referenced ManagedElement is "
       "conformant.  Note: This association may apply to any Managed "
       "Element.  Typical usage will apply it to a higher level "
       "instance, such as a System, NameSpace, or Service.  When "
       "applied to a higher level instance, all constituent parts MUST "
       "behave appropriately in support of the ManagedElement's "
       "conformance to the named RegisteredProfile.")]
class CIM_ElementConformsToProfile {

      [Key, Description (
          "The RegisteredProfile to which the ManagedElement "
          "conforms.")]
   CIM_RegisteredProfile REF ConformantStandard;

      [Key, Description (
          "The ManagedElement that conforms to the RegisteredProfile.")]
   CIM_ManagedElement REF ManagedElement;
};


// ===================================================================
// ElementLocation
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "ElementLocation associates a ManagedElement with a Location "
       "for positioning, inventory, maintenance and similar purposes.  "
       "PhysicalElements can certainly have Locations - this is "
       "explicitly defined in a subclass, PhysicalElement Location.  "
       "However, other ManagedElements may also be associated with "
       "Locations.  For example, Organizations may be 'in' one or more "
       "Locations, or Services may be restricted to a Location.")]
class CIM_ElementLocation {

      [Key, Description (
          "The ManagedElement whose Location is specified.")]
   CIM_ManagedElement REF Element;

      [Key, Description (
          "The element's Location.")]
   CIM_Location REF PhysicalLocation;
};


// ===================================================================
// PhysicalElementLocation
// ===================================================================
[Association, Version ("2.7.0"), Description (
    "PhysicalElementLocation associates a PhysicalElement with "
    "a Location object for inventory or replacement purposes.") ]
class CIM_PhysicalElementLocation : CIM_ElementLocation {
    
    [Override ("Element"), Description (
        "The PhysicalElement whose Location is specified.") ]
    CIM_PhysicalElement REF Element;
    
    [Override ("PhysicalLocation"), Max (1),
        Description ("The PhysicalElement's Location.") ]
    CIM_Location REF PhysicalLocation;
};


// ===================================================================
// Synchronized
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "Indicates that two ManagedElements 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 ManagedElement that is "
          "synchronized with the entity referenced as SyncedElement.")]
   CIM_ManagedElement REF SystemElement;

      [Key, Description (
          "SyncedElement represents another ManagedElement that is "
          "synchronized with the entity referenced as SystemElement.")]
   CIM_ManagedElement REF SyncedElement;

      [Description (
          "The point in time that the Elements were synchronized.")]
   datetime WhenSynced;

      [Description (
          "Boolean indicating whether synchronization is maintained.")]
   boolean SyncMaintained;
};


// ===================================================================
// StorageSynchronized
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "Indicates that two Storage objects were replicated at the "
       "specified point in time.  If the CopyType property is set to "
       "'Sync' (=3), then synchronization of the Storage objects is "
       "preserved.")]
class CIM_StorageSynchronized : CIM_Synchronized {

      [Override ( "SystemElement" ), Description (
          "SystemElement represents the Storage that is the source of "
          "the replication.")]
   CIM_ManagedElement REF SystemElement;

      [Override ( "SyncedElement" ), Description (
          "SyncedElement represents the Storage that is the target of "
          "the replication.")]
   CIM_ManagedElement REF SyncedElement;

      [Description (
          "CopyType describes the Replication Policy.  Values are: \n"
          "Async: create and maintain an asynchronous copy of the "
          "source.  \n"
          "Sync: create and maintain a synchronized copy of the "
          "source.  \n"
          "UnSyncAssoc: create an unsynchronized copy and maintain an "
          "association to the source."), 
       ValueMap { "2", "3", "4", "..", "0x8000.." }, 
       Values { "Async", "Sync", "UnSyncAssoc", "DMTF Reserved",
          "Vendor Specific" }]
   uint16 CopyType;

      [Description (
          "ReplicaType provides information on how the Replica is "
          "being maintained.  Values are: \n"
          "Full Copy: This indicates that a full copy of the source "
          "object is (or will be) generated .  \n"
          "Before Delta: This indicates that the source object will be "
          "maintained as a delta data from the replica.  \n"
          "After Delta: This indicates that the replica will be "
          "maintained as delta data from the source object.  \n"
          "Log: This indicates that the replica object is being "
          "maintained as a log of changes to the source.  \n"
          "Not Specified: The method of maintaining the copy is not "
          "specified."), 
       ValueMap { "0", "2", "3", "4", "5","..", "0x8000.." }, 
       Values { "Not Specified", "Full Copy", "Before Delta",
          "After Delta", "Log","DMTF Reserved", "Vendor Specific" }]
   uint16 ReplicaType;

      [Description (
          "SyncState describes the state of the association with "
          "respect to Replication activity.  Values are: \n"
          "Initialized: The link to enable replication is "
          "established.  \n"
          "PrepareInProgress: Preparation for Replication is in "
          "progress.  \n"
          "Prepared: All necessary preparation has completed.  \n"
          "ResyncInProgress: Synchronization or Resynchronization is "
          "in progress.  \n"
          "This may be the initial 'copy' or subsequent changes being "
          "copied.  \n"
          "Synchronized: An Async or Sync replication is currently "
          "synchronized.  When this value is set, SyncMaintained will "
          "be true.  \n"
          "FractureInProgress: An operation to fracture an Async or "
          "Sync replication is in progress.  \n"
          "Fractured: An Async or Sync replication is fractured.  \n"
          "QuiesceInProgress: A quiesce operation is in progress.  \n"
          "Quiesced: The replication has been quiesced and is ready "
          "for a change.  \n"
          "RestoreInProgress: An operation is in progress to copy the "
          "Synced object to the System object.  \n"
          "Idle: The 'normal' state for an UnSyncAssoc replica.  \n"
          "Broken: The relationship is non-functional due to errors in "
          "the source, the target, the path between the two or space "
          "constraints."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
          "12", "13", "..", "0x8000.." }, 
       Values { "Initialized", "PrepareInProgress", "Prepared",
          "ResyncInProgress", "Synchronized", "Fracture In Progress",
          "QuiesceInProgress", "Quiesced", "Restore In Progresss",
          "Idle", "Broken", "Fractured", "DMTF Reserved",
          "Vendor Specific" }]
   uint16 SyncState;
};

// ==================	=================================================
// SynchronizedMember
// ===================================================================
[Association, Aggregation, Version ("2.8.0"), Description ("CR from SVI") ]
class CIM_SynchronizedMember : CIM_MemberOfCollection
{
    [Override("Collection"),Key, Aggregate, 
        Description ("The Collection that aggregates members.") ]    
    CIM_SynchronizedSet REF Collection;

    [Override("Member"), Key, 
        Description ("The aggregated member of the Collection.") ]    
    CIM_StorageSynchronized REF Member;   
};



// ===================================================================
// ElementStatisticalData
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "CIM_ElementStatisticalData is an association that relates a "
       "ManagedElement to its StatisticalData.  Note that the "
       "cardinality of the ManagedElement reference is Min(1), "
       "Max(1).  This cardinality mandates the instantiation of the "
       "ElementStatisticalData association for the referenced instance "
       "of CIM_StatisticalData.  ElementStatisticalData describes the "
       "existence requirements and context for the "
       "CIM_StatisticalData, relative to a specific ManagedElement.")]
class CIM_ElementStatisticalData {

      [Key, Min ( 1 ), Max ( 1 ), Description (
          "The ManagedElement for which statistical or metric data is "
          "defined.")]
   CIM_ManagedElement REF ManagedElement;

      [Key, Description (
          "The statistic information/object.")]
   CIM_StatisticalData REF Stats;
};


// ===================================================================
// Indication
// ===================================================================
   [Indication, Abstract, Version ( "2.7.0"), Description (
       "CIM_Indication is the abstract root class for all "
       "notifications about changes in schema, objects and their data, "
       "and about events detected by providers and instrumentation.  "
       "Subclasses represent specific types of notifications.  \n"
       "\n"
       "To receive an Indication, a consumer (or subscriber) must "
       "create an instance of CIM_IndicationFilter describing the "
       "criteria of the notification, an instance of "
       "CIM_ListenerDestination describing the delivery of the "
       "notification, and an instance of CIM_IndicationSubscription "
       "associating the Filter and Handler.") ]
class CIM_Indication {

      [Description (
          "An identifier for the Indication.  This property is similar "
          "to a key value in that it can be used for identification, "
          "when correlating Indications (see the CorrelatedIndications "
          "array).  Its value SHOULD be unique as long as Alert "
          "correlations are reported, but MAY be reused or left NULL "
          "if no future Indications will reference it in their "
          "CorrelatedIndications array."), 
       MappingStrings { 
          "Recommendation.ITU|X733.Notification identifier"} ]
   string IndicationIdentifier;

      [Description (
          "A list of IndicationIdentifiers whose notifications are "
          "correlated with (related to) this one."), 
       MappingStrings { 
          "Recommendation.ITU|X733.Correlated notifications"} ]
   string CorrelatedIndications[];

      [Description (
          "The time and date of creation of the Indication.  The "
          "property may be set to NULL if the entity creating the "
          "Indication is not capable of determing this information.  "
          "Note that IndicationTime may be the same for two "
          "Indications that are generated in rapid succession.") ]
   datetime IndicationTime;
};



// ===================================================================
// InstIndication
// ===================================================================
   [Indication, Abstract, Version ( "2.6.0"), Description (
       "CIM_InstIndication is an abstract superclass describing "
       "changes to instances.  Subclasses represent specific types of "
       "change notifications, such as instance creation, deletion and "
       "modification.") ]
class CIM_InstIndication : CIM_Indication {

      [Required, Description (
          "A copy of the instance that changed to generate the "
          "Indication.  SourceInstance contains the current values of "
          "the properties selected by the Indication Filter's Query.  "
          "In the case of CIM_InstDeletion, the property values are "
          "copied before the instance is deleted."), 
       EmbeddedObject ]
   string SourceInstance;
};


// ===================================================================
// InstCreation
// ===================================================================
[Indication, Version("2.6.0"), Description (
    "CIM_InstCreation notifies when a new instance is created.") ]
class CIM_InstCreation : CIM_InstIndication {
};


// ===================================================================
// InstDeletion
// ===================================================================
[Indication, Version("2.6.0"), Description (
    "CIM_InstDeletion notifies when an existing instance is deleted.") ]
class CIM_InstDeletion : CIM_InstIndication {
};


// ===================================================================
// InstModification
// ===================================================================
   [Indication, Version ("2.6.0"), Description (
       "CIM_InstModification notifies when an instance is modified.") ]
class CIM_InstModification : CIM_InstIndication {

      [Required, Description (
          "A copy of the 'previous' instance whose change generated "
          "the Indication.  PreviousInstance contains 'older' values "
          "of an instance's properties (as compared to "
          "SourceInstance), selected by the IndicationFilter's Query."), 
       EmbeddedObject ]
   string PreviousInstance;
};


// ===================================================================
// ProcessIndication
// ===================================================================
[Indication, Abstract, Version("2.6.0"), Description (
    "An abstract superclass for specialized Indication classes, "
    "addressing specific changes and alerts published by providers "
    "and instrumentation. Subclasses include AlertIndication (with "
    "properties such as PerceivedSeverity and ProbableCause), and "
    "SNMPTrapIndication (which recasts Traps as CIM indications).") ]
class CIM_ProcessIndication : CIM_Indication {
};


// ===================================================================
// IndicationSubscription
// ===================================================================
   [Association, Version ( "2.7.0"), Description (
       "CIM_IndicationSubscription describes a flow of Indications.  "
       "The flow is specified by the referenced Filter, and directed "
       "to the referenced destination or process in the Handler.  "
       "Property values of the referenced CIM_IndicationFilter "
       "instance and CIM_ListenerDestination instance MAY "
       "significantly effect the definition of the subscription.  "
       "E.g., a subscription associated with a \"Transient\" "
       "destination MAY be deleted when the destination terminates or "
       "is no longer available.")]

class CIM_IndicationSubscription {

      [Key, Description (
          "The Filter that defines the criteria and data of the "
          "possible Indications of this subscription.") ]
   CIM_IndicationFilter REF Filter;

      [Key, Description (
          "The Handler addressing delivery of the possible Indications "
          "of this subscription.") ]
   CIM_ListenerDestination REF Handler;

      [Description (
          "Defines the desired behavior for a subscription when a "
          "fatal error occurs in one of the Indication processing "
          "subcomponents (e.g., Indication processor, Indication or "
          "instance provider, or Indication handler) and the "
          "Indication cannot be successfully sent.  Specifically, a "
          "failure implies that some aspect of Indication generation, "
          "processing or dispatch is no longer functioning and "
          "Indications may be lost.  If the value of "
          "OnFatalErrorPolicy is 2 (\"Ignore\") or not set (NULL), the "
          "subscription MUST continue to be processed in a 'best "
          "effort' mode.  This mode of operation can lead to "
          "unpredictable, and potentially misleading results, because "
          "Indications may be lost.  If the value is 3 (\"Disable\"), "
          "the subscription MUST be disabled.  With this policy, no "
          "new Indications will be generated or dispatched until the "
          "subscription is explicitly enabled.  This is accomplished "
          "via the property, SubscriptionState.  If the value is 4 "
          "(\"Remove\"), the subscription MUST be deleted.  Selecting "
          "this policy has the same effect as issuing a DeleteInstance "
          "operation on this subscription instance."), 
       ValueMap { "1", "2", "3", "4"}, 
       Values { "Other", "Ignore", "Disable", "Remove"} ]
   uint16 OnFatalErrorPolicy;

      [Description (
          "A string defining \"Other\" values for OnFatalErrorPolicy.  "
          "This value MUST be set to a non NULL value when "
          "OnFatalErrorPolicy is set to a value of 1 (\"Other\").  For "
          "all other values, the OtherOnFatalErrorPolicy MUST be "
          "NULL.") ]
   string OtherOnFatalErrorPolicy;

      [Description (
          "The FailureTriggerTimeInterval is used by the client to "
          "specify a recommended minimum delay before the "
          "OnFatalErrorPolicy is implemented."), 
       Units ( "Seconds") ]
   uint64 FailureTriggerTimeInterval;

      [Write, Description (
          "Indicates the current processing state of the "
          "subscription."), 
       ValueMap { "0", "1", "2", "3", "4"}, 
       Values { "Unknown", "Other", "Enabled", "Enabled Degraded",
          "Disabled"} ]
   uint16 SubscriptionState;

      [Description (
          "A string defining \"Other\" values for SubscriptionState.  "
          "This value MUST be set to a non NULL value when "
          "SubscriptionState is set to a value of 1 (\"Other\").  For "
          "all other values, the OtherSubscriptionState MUST be NULL.") ]
   string OtherSubscriptionState;

      [Description (
          "Date and time of the last state change.  This value is "
          "based on the notion of local date and time of the Managed "
          "System Element running the Indication processing "
          "subcomponents.") ]
   datetime TimeOfLastStateChange;

      [Write, Description (
          "SubscriptionDuration defines the desired length of the "
          "subscription.  Indications generated after the duration of "
          "the subscription has exceeded SubscriptionDuration MUST NOT "
          "be sent.  The duration of a subscription MAY be changed by "
          "modifying this property.  An expired subscription MAY be "
          "deleted and MUST NOT be modified.  If the value of "
          "SubscriptionDuration is not set, the subscription MUST be "
          "treated as having no expiration date."), 
       Units ( "Seconds") ]
   uint64 SubscriptionDuration;

      [Description (
          "SubscriptionStartTime is the time the subscription was "
          "started.  The value of this property is computed based on "
          "the notion of date and time of the ManagedSystemElement "
          "running the Indication processing subcomponents.") ]
   datetime SubscriptionStartTime;

      [Description (
          "SubscriptionTimeRemaining is a computed value that provides "
          "a snapshot of the time remaining in the Subscription."), 
       Units ( "Seconds") ]
   uint64 SubscriptionTimeRemaining;

      [Description (
          "The RepeatNotificationPolicy property defines the desired "
          "behavior for handling Indications that report the "
          "occurrence of the same underlying event (e.g., the disk is "
          "still generating I/O errors and has not yet been "
          "repaired).  The defined semantics for the "
          "RepeatNotificationCount, RepeatNotificationInterval, and "
          "RepeatNotificationGap properties depend on the value of "
          "RepeatNotificationPolicy, but values for these properties "
          "MUST be set if the property is defined for the selected "
          "policy.  If the value of RepeatNotificationPolicy is 0 "
          "(\"Unknown\") or not set, no special processing for repeat "
          "Indications is defined by the subscription.  The semantics "
          "associated with the handling of repeat Indications MAY be "
          "defined by the Indication processing subcomponents.  If the "
          "value of RepeatNotificationPolicy is 2 (\"None\"), special "
          "processing of repeat Indications MUST NOT be performed.  If "
          "the value is 3 (\"Suppress\") the first "
          "RepeatNotificationCount Indications, describing the same "
          "event, MUST be sent and all subsequent Indications for this "
          "event suppressed for the remainder of the time interval "
          "RepeatNotificationInterval.  A new interval starts when the "
          "next Indication for this event is received.  If the value "
          "of RepeatNotificationPolicy is 4 (\"Delay\") and an "
          "Indication is received, this Indication MUST be suppressed "
          "if, including this Indication, RepeatNoticationCount or "
          "fewer Indications for this event have been received during "
          "the prior time interval defined by "
          "RepeatNotificationInterval.  If this Indication is the "
          "RepeatNotificationCount + 1 Indication, this Indication "
          "MUST be sent and all subsequent Indications for this event "
          "ignored until the RepeatNotificationGap has elapsed.  A "
          "RepeatNotificationInterval MAY NOT overlap a "
          "RepeatNotificationGap time interval."), 
       ValueMap { "0", "1", "2", "3", "4"}, 
       Values { "Unknown", "Other", "None", "Suppress", "Delay"} ]
   uint16 RepeatNotificationPolicy;

      [Description (
          "A string defining \"Other\" values for "
          "RepeatNotificationPolicy.  This value MUST be set to a non "
          "NULL value when RepeatNotificationPolicy is set to a value "
          "of 1 (\"Other\").  For all other values, the "
          "OtherRepeatNotificationPolicy MUST be NULL.") ]
   string OtherRepeatNotificationPolicy;

      [Description (
          "Defines the time interval for the repeat notification "
          "policy calculation."), 
       Units ( "Seconds") ]
   uint64 RepeatNotificationInterval;

      [Description (
          "Defines the gap interval for the repeat notification policy "
          "calculation."), 
       Units ( "Seconds") ]
   uint64 RepeatNotificationGap;

      [Description (
          "Defines the count property for the repeat notification "
          "policy calculation.") ]
   uint16 RepeatNotificationCount;
};


// ===================================================================
// 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;
};

//====================================================================
//  CIM_IndicationHandlerCIMXML
//====================================================================
   [Deprecated { "CIM_ListenerDestinationCIMXML"},
       Version ( "2.8.0"), Description (
       "CIM_IndicationHandlerCIMXML describes the destination for "
       "Indications to be delivered via CIM-XML."),
       CreateRole("Administrator"), DeleteRole("Administrator")]
class CIM_IndicationHandlerCIMXML : CIM_IndicationHandler {

      [Deprecated { "CIM_ListenerDestinationCIMXML.Destination"},
       Required, Description (
          "The destination URL to which CIM-XML Indication messages "
          "are to be delivered.  The scheme prefix MUST be consistent "
          "with the DMTF CIM-XML Specifications.  If a scheme prefix "
          "is not specified, the scheme \"http:\" MUST be assumed.") ]
   string Destination;
};





//====================================================================
// The following classes are added because of the PlugFest requirement
//====================================================================

// ==================================================================
// cim_physicalcomponent
// ==================================================================
   [Version ( "2.8.0" ), Description (
       "The PhysicalComponent class represents any low-level or basic "
       "Component within a Package.  A Component object either can not "
       "or does not need to be decomposed into its constituent parts.  "
       "For example, an ASIC (or Chip) can not be further decomposed.  "
       "A tape for data storage (PhysicalMedia) does not need to be "
       "decomposed.  Any PhysicalElement that is not a Link, "
       "Connector, or Package is a descendent (or member) of this "
       "class.  For example, the UART chipset on an internal modem "
       "Card would be a subclass (if additional properties or "
       "associations are defined) or an instance of "
       "PhysicalComponent.")]
class CIM_PhysicalComponent : CIM_PhysicalElement {

      [Experimental, Description (
          "The RemovalCapabilites property is used to describe the "
          "conditions under which a PhysicalPackage can be removed.  "
          "Since all PhysicalPackages are not removable, this property "
          "defaults to 2, 'Not Applicable'."), 
       ValueMap {"0", "2", "3", "4"}, 
       Values {"Unknown", "Not Applicable", "Removable when off",
          "Removable when on or off"} ]
   uint16 RemovalConditions = 2;

      [Deprecated {"PhysicalComponent.RemovalConditions"}, 
       Description (
          "The use of this property is being deprecated.  Instead "
          "RemovalConditions should be used.  The RemovalConditions "
          "property addresses whether a PhysicalComponent is removable "
          "with or without power being applied.\n"
          "\n"
          "A PhysicalComponent is Removable if it is designed to be "
          "taken in and out of the physical container in which it is "
          "normally found, without impairing the function of the "
          "overall packaging.  A Component can still be Removable if "
          "power must be 'off' in order to perform the removal.  If "
          "power can be 'on' and the Component removed, then the "
          "Element is both Removable and HotSwappable.  For example, "
          "an upgradeable Processor chip is Removable.") ]
   boolean Removable;

      [Deprecated {"No Value"}, Description (
          "The use of this property is being deprecated because it is "
          "redundant with the FRU class and its associations.  A "
          "PhysicalComponent is Replaceable if it is possible to "
          "replace (FRU or upgrade) the Element with a physically "
          "different one.  For example, some ComputerSystems allow the "
          "main Processor chip to be upgraded to one of a higher clock "
          "rating.  In this case, the Processor is said to be "
          "Replaceable.  All Removable Components are inherently "
          "Replaceable.") ]
   boolean Replaceable;

      [Deprecated { "CIM_PhysicalComponent.RemovalConditions" }, 
       Description (
          "The use of this property is being deprecated.  Instead "
          "RemovalConditions should be used.  The RemovalConditions "
          "property addresses whether a PhysicalComponent is removable "
          "with or without power being applied.  \n"
          "\n"
          "A PhysicalComponent is HotSwappable if it is possible to "
          "replace the Element with a physically different but "
          "equivalent one while the containing Package has power "
          "applied to it (ie, is 'on').  For example, a fan Component "
          "may be designed to be HotSwappable.  All HotSwappable "
          "Components are inherently Removable and Replaceable.")]
   boolean HotSwappable;
};

// ==================================================================
// cim_physicalmedia
// ==================================================================
   [Version ("2.6.0"), Description (
       "The PhysicalMedia class represents any type of documentation "
       "or storage medium, such as tapes, CDROMs, etc.  This class is "
       "typically used to locate and manage Removable Media (versus "
       "Media sealed with the MediaAccessDevice, as a single Package, "
       "as is the case with hard disks).  However, 'sealed' Media can "
       "also be modeled using this class, where the Media would then "
       "be associated with the PhysicalPackage using the "
       "PackagedComponent relationship.") ]
class CIM_PhysicalMedia : CIM_PhysicalComponent {

      [Description (
          "The number of bytes that can be read from or written to a "
          "Media.  This property is not applicable to \"Hard Copy\" "
          "(documentation) or cleaner Media.  Data compression should "
          "not be assumed, as it would increase the value in this "
          "property.  For tapes, it should be assumed that no "
          "filemarks or blank space areas are recorded on the Media."), 
       Units ("Bytes") ]
   uint64 Capacity;

      [Description (
          "Specifies the type of the PhysicalMedia, as an enumerated "
          "integer.  The MediaDescription property is used to provide "
          "more explicit definition of the Media type, whether it is "
          "pre-formatted, compatability features, etc."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
          "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
          "30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
          "40", "41", "42", "43", "44", "45", "46", "47", "48", "49",
          "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
          "60", "61", "62", "63", "64", "65", "66" }, 
       Values { "Unknown", "Other", "Tape Cartridge", "QIC Cartridge",
          "AIT Cartridge", "DTF Cartridge", "DAT Cartridge",
          "8mm Tape Cartridge", "19mm Tape Cartridge", "DLT Cartridge", 
          // 10       
          "Half-Inch Magnetic Tape Cartridge", "Cartridge Disk",
          "JAZ Disk", "ZIP Disk", "SyQuest Disk",
          "Winchester Removable Disk", "CD-ROM", "CD-ROM/XA", "CD-I",
          "CD Recordable", 
          // 20      
          "WORM", "Magneto-Optical", "DVD", "DVD-RW+", "DVD-RAM",
          "DVD-ROM", "DVD-Video", "Divx", "Floppy/Diskette",
          "Hard Disk", 
          // 30       
          "Memory Card", "Hard Copy", "Clik Disk", "CD-RW", "CD-DA",
          "CD+", "DVD Recordable", "DVD-RW", "DVD-Audio", "DVD-5", 
          // 40      
          "DVD-9", "DVD-10", "DVD-18", "Magneto-Optical Rewriteable",
          "Magneto-Optical Write Once",
          "Magneto-Optical Rewriteable (LIMDOW)",
          "Phase Change Write Once", "Phase Change Rewriteable",
          "Phase Change Dual Rewriteable", "Ablative Write Once", 
          // 50      
          "Near Field Recording", "MiniQic", "Travan",
          "8mm Metal Particle", "8mm Advanced Metal Evaporate", "NCTP",
          "LTO Ultrium", "LTO Accelis", "9 Track Tape",
          "18 Track Tape", 
          // 60       
          "36 Track Tape", "Magstar 3590", "Magstar MP", "D2 Tape",
          "Tape - DST Small", "Tape - DST Medium", "Tape - DST Large" }, 
       ModelCorrespondence { "CIM_PhysicalMedia.MediaDescription" }]
   uint16 MediaType;

      [Description (
          "Additional detail related to the MediaType enumeration.  "
          "For example, if value 3 (\"QIC Cartridge\") is specified, "
          "this property could indicate whether the tape is wide or "
          "1/4 inch, whether it is pre-formatted, whether it is Travan "
          "compatible, etc."), 
       ModelCorrespondence {"CIM_PhysicalMedia.MediaType"} ]
   string MediaDescription;

      [Description (
          "Boolean specifying whether the Media is currently write "
          "protected by some kind of physical mechanism, such as a "
          "protect tab on a floppy diskette.") ]
   boolean WriteProtectOn;

      [Description (
          "Boolean indicating that the PhysicalMedia is used for "
          "cleaning purposes and not data storage.") ]
   boolean CleanerMedia;

      [Description (
          "Size of the Media in inches.  For example, '3.5' would be "
          "entered for a 3.5 inch disk, or '12' would be entered for a "
          "12 inch optical disk.  On the other hand, '0.5' would be "
          "defined for a 1/2 inch tape."), 
       Units ("Inches") ]
   real32 MediaSize;

      [Description (
          "For removable Media, the maximum number of times that the "
          "Media can be mounted before it should be retired.  For "
          "cleaner Media, this is the maximum number of Drive cleans "
          "that can be performed.  For nonremovable Media, such as "
          "hard disks, this property is not applicable and should be "
          "set to 0.") ]
   uint64 MaxMounts;

      [Description (
          "For removable or cleaner Media, the number of times that "
          "the Media has been mounted for data transfer or to clean a "
          "Drive.  For nonremovable Media, such as hard disks, this "
          "property is not applicable and should be set to 0."), 
       Counter, 
       ModelCorrespondence {"CIM_PhysicalMedia.MaxMounts"} ]
   uint64 MountCount;

      [Description (
          "Boolean indicating that the Media has two recording sides "
          "(TRUE) or only a single side (FALSE).  Examples of dual "
          "sided Media include DVD-ROM and some optical disks.  "
          "Examples of single sided Media are tapes and CD-ROM.") ]
   boolean DualSided;

      [Description (
          "One or more strings on 'labels' on the PhysicalMedia.  The "
          "format of the labels and their state (readable, unreadable, "
          "upside-down) are indicated in the LabelFormats and "
          "LabelStates array properties."), 
       ArrayType ("Indexed"), 
       ModelCorrespondence {"CIM_PhysicalMedia.LabelStates",
          "CIM_PhysicalMedia.LabelFormats"} ]
   string PhysicalLabels[];

      [Description (
          "An array of enumerated integers describing the states of "
          "each of the labels on a PhysicalMedia.  The Labels "
          "themselves are listed in the PhysicalLabels property.  "
          "Note, each entry of this array is related to the entry in "
          "PhysicalLabels that is located at the same index."), 
       ValueMap {"0", "1", "2"}, 
       Values {"OK/Readable", "Unreadable", "Upside Down"}, 
       ArrayType ("Indexed"), 
       ModelCorrespondence {"CIM_PhysicalMedia.PhysicalLabels"} ]
   uint16 LabelStates[];

      [Description (
          "An array of enumerated integers describing the formats of "
          "each of the labels on a PhysicalMedia.  The Labels "
          "themselves are listed in the PhysicalLabels property.  "
          "Note, each entry of this array is related to the entry in "
          "PhysicalLabels that is located at the same index."), 
       ValueMap {"0", "1", "2", "3", "4", "5"}, 
       Values {"Barcode", "Radio Frequency Identification",
           "OCR (Optical Character Recognition)",
           "MICR (Magnetic Ink Character Recognition)",
           "7 Character Barcode", "9 Character Barcode"}, 
       ArrayType ("Indexed"), 
       ModelCorrespondence {"CIM_PhysicalMedia.PhysicalLabels"} ]
   uint16 LabelFormats[];

      [Description (
          "For removable or cleaner Media, the date and time that the "
          "Media was last mounted.  For nonremovable Media, such as "
          "hard disks, this property has no meaning and is not "
          "applicable.") ]
   datetime TimeOfLastMount;

      [Description (
          "For removable or cleaner Media, the total time (in seconds) "
          "that the Media has been mounted for data transfer or to "
          "clean a Drive.  For nonremovable Media, such as hard disks, "
          "this property is not applicable and should be set to 0."), 
       Units ("Seconds") ]
   uint64 TotalMountTime;
};


// ==================================================================
// cim_softwareidentity
// ==================================================================
   [Version ( "2.8.0" ), Description (
       "SoftwareIdentity represents software, viewed as an asset "
       "and/or individually identifiable entity (similar to Physical "
       "Element).  It does NOT indicate whether the software is "
       "installed, executing, etc.  (The latter is the role of the "
       "SoftwareFeature/ SoftwareElement classes and the Application "
       "Model.) Since software may be acquired, SoftwareIdentity can "
       "be associated with a Product using the "
       "ProductSoftwareComponent relationship.  \n"
       "Note that the Application Model manages the deployment and "
       "installation of software via the classes, SoftwareFeatures and "
       "SoftwareElements.  The deployment/installation concepts are "
       "related to the asset/identity one.  In fact, a "
       "SoftwareIdentity may correspond to a Product, or to one or "
       "more SoftwareFeatures or SoftwareElements - depending on the "
       "granularity of these classes and the deployment model.  The "
       "correspondence of Software Identity to Product, "
       "SoftwareFeature or SoftwareElement is indicated using the "
       "ConcreteIdentity association.  Note that there may not be "
       "sufficient detail or instrumentation to instantiate "
       "ConcreteIdentity.  And, if the association is instantiated, "
       "some duplication of information may result.  For example, the "
       "Vendor described in the instances of Product and "
       "SoftwareIdentity MAY be the same.  However, this is not "
       "necessarily true, and it is why vendor and similar information "
       "are duplicated in this class.  \n"
       "Note that ConcreteIdentity can also be used to describe the "
       "relationship of the software to any LogicalFiles that result "
       "from installing it.  As above, there may not be sufficient "
       "detail or instrumentation to instantiate this association.")]
class CIM_SoftwareIdentity : CIM_LogicalElement {

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this "
          "class.  In order to ensure uniqueness within the NameSpace, "
          "the value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':').  When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>.  \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements.  If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace.  "
          "\nFor DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]
   string InstanceID;

      [Description (
          "The major number component of the software's version "
          "information - for example, '12' from version 12.1(3)T.  "
          "This property is defined as a numeric value to allow the "
          "determination of 'newer' vs.  'older' releases.  A 'newer' "
          "major release is indicated by a larger numeric value.") ]
   uint16 MajorVersion;

      [Description (
          "The minor number component of the software's version "
          "information - for example, '1' from version 12.1(3)T.  This "
          "property is defined as a numeric value to allow the "
          "determination of 'newer' vs.  'older' releases.  A 'newer' "
          "minor release is indicated by a larger numeric value.") ]
   uint16 MinorVersion;

      [Description (
          "The revision or maintenance release component of the "
          "software's version information - for example, '3' from "
          "version 12.1(3)T.  This property is defined as a numeric "
          "value to allow the determination of 'newer' vs.  'older' "
          "releases.  A 'newer' revision is indicated by a larger "
          "numeric value.") ]
   uint16 RevisionNumber;

      [Description (
          "The build number of the software.") ]
   uint16 BuildNumber;

      [Description (
          "A string representing the complete software version "
          "information - for example, '12.1(3)T'.  This string and the "
          "numeric major/minor/revision/build properties are "
          "complementary.  Since vastly different representations and "
          "semantics exist for versions, it is not assumed that one "
          "representation is sufficient to permit a client to perform "
          "computations (i.e., the values are numeric) and a user to "
          "recognize the software's version (i.e., the values are "
          "understandable and readable).  Hence, both numeric and "
          "string representations of version are provided.") ]
   string VersionString;

      [Description (
          "Specifies the target operating systems of the software.  "
          "Due to the extreme variability in operating systems, this "
          "property is defined as a string array.") ]
   string TargetOperatingSystems[];

      [Description (
          "Manufacturer of this software.") ]
   string Manufacturer;

      [Description (
          "The language editions supported by the software.  The "
          "language codes defined in ISO 639 should be used.") ]
   string Languages[];

      [Description (
          "An array of enumerated integers that classify this "
          "software.  For example, the software MAY be instrumentation "
          "(value=5) or firmware and diagnostic software (10 and 7).  "
          "The use of value 6, Firmware/BIOS, is being deprecated.  "
          "Instead, either the value 10 (Firmware) and/or 11 "
          "(BIOS/FCode) SHOULD be used."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11", "..", "0x8000..0xFFFF" }, 
       Values { "Unknown", "Other", "Driver", "Configuration Software",
          "Application Software", "Instrumentation", "Firmware/BIOS",
          "Diagnostic Software", "Operating System", "Middleware",
          "Firmware", "BIOS/FCode", "DMTF Reserved",
       "Vendor Reserved" }, ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_SoftwareIdentity.ClassificationDescriptions" }]
   uint16 Classifications[];

      [Description (
          "An array of free-form strings providing more detailed "
          "explanations for any of the entries in the Classifications "
          "array.  Note that each entry is related to one in the "
          "Classifications array located at the same index."), 
       ArrayType ("Indexed"), 
       ModelCorrespondence {"CIM_SoftwareIdentity.Classifications"} ]
   string ClassificationDescriptions[];
   
      [Description (
          "A manufacturer-allocated number used to identify the "
          "software.")]
   string SerialNumber;
};


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

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

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


// ==================================================================
// cim_container
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
       "The Container association represents the relationship between "
       "a contained and a containing PhysicalElement.  A containing "
       "object must be a PhysicalPackage.") ]
class CIM_Container : CIM_Component {

      [Aggregate, Override ("GroupComponent"), Max (1), Description (
          "The PhysicalPackage that contains other PhysicalElements, "
          "including other Packages."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalContainedIn"} ]
   CIM_PhysicalPackage REF GroupComponent;

      [Override ("PartComponent"), Description (
          "The PhysicalElement which is contained in the Package.") ]
   CIM_PhysicalElement REF PartComponent;

      [Description (
          "A free-form string representing the positioning of the "
          "PhysicalElement within the PhysicalPackage.  Information "
          "relative to stationary elements in the Container (for "
          "example, 'second drive bay from the top'), angles, "
          "altitudes and other data may be recorded in this property.  "
          "This string could supplement or be used in place of "
          "instantiating the CIM_Location object."), 
       MappingStrings { "MIB.IETF|Entity-MIB.entPhysicalParentRelPos"} ]
   string LocationWithinContainer;
};


// ==================================================================
// cim_packagedcomponent
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
       "A Component is typically contained by a PhysicalPackage, such "
       "as a Chassis or Card.  The PackagedComponent association makes "
       "this relationship explicit.  In the first sentence, the word, "
       "'typically', is used.  This is because a Component may be "
       "removed from, or not yet inserted into, its containing Package "
       "(ie, the Removable boolean is TRUE).  Therefore, a Component "
       "may not always be associated with a container.") ]
class CIM_PackagedComponent : CIM_Container {

      [Aggregate, Override ("GroupComponent"), Max (1), Description (
          "The PhysicalPackage that contains Component(s).") ]
   CIM_PhysicalPackage REF GroupComponent;

      [Override ("PartComponent"), Description (
          "The PhysicalComponent which is contained in the Package.") ]
   CIM_PhysicalComponent REF PartComponent;
};


// ==================================================================
// cim_devicesoftwareidentity
// ==================================================================
   [Association, Experimental, Version ("2.7.1000"), Description (
       "DeviceSoftwareIdentity allows a device to report its software "
       "related asset information (firmware, drivers, configuration "
       "software, and etc.)\n"
       "Note that the Application Model manages the deployment and "
       "installation of software via the classes, SoftwareFeatures and "
       "SoftwareElements.  If there is sufficient detail or "
       "instrumentation to instantiate the deployment/installation "
       "concepts then the DeviceSoftware association should be used to "
       "tie LogicalDevices to their SoftwareElements.") ]
class CIM_DeviceSoftwareIdentity : CIM_Dependency {

      [Override ("Antecedent"), Description (
          "A LogicalDevice's Software Asset.") ]
   CIM_SoftwareIdentity REF Antecedent;

      [Override ("Dependent"), Description (
          "The LogicalDevice that requires or uses the software.") ]
   CIM_LogicalDevice REF Dependent;

      [Description (
          "Indicates the device's ability to upgrade this software "
          "asset.\n"
          "'Resides off device'(2), indicates the persistence of the "
          "software is outside of the device.  Typically for a device "
          "this software is part of the OperatingSystem is typically "
          "upgradeable.\n"
          "'Owner Upgradeable' (3), indicates the persistence of the "
          "software is on the device and is upgradeable by the owner.\n"
          "'Factory Upgradeable' (4), indicates the persistence of the "
          "software is on the device and is upgradeable by the "
          "manufacturer.\n"
          "'Not Upgradeable' (5), indicates the presistence of the "
          "software is on the device and is not upgradeable.  (i.e.  "
          "burned into a non replaceable ROM chip."), 
       ValueMap {"0", "1", "2", "3", "4", "5", "..", "0x8000..0xFFFF"}, 
       Values {"Unknown", "Other", "Resides off device",
           "Owner Upgradeable", "Factory Upgradeable",
           "Not Upgradeable", "DMTF Reserved", "Vendor Reserved"}, 
       ModelCorrespondence { 
          "CIM_DeviceSoftwareIdentity.OtherUpgradeCondition"} ]
   uint16 UpgradeCondition;

      [Description (
          "Describes the upgrade condition, when UpgradeCondition is "
          "set to 1 (\"Other\")."), 
       ModelCorrespondence { 
          "CIM_DeviceSoftwareIdentity.UpgradeCondition"} ]
   string OtherUpgradeCondition;
};


// ==================================================================
// cim_productparentchild
// ==================================================================
   [Association, Aggregation, Composition, Version ("2.7.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 {

      [Key, Aggregate, Description (
          "The parent Product in the association.") ]
   CIM_Product REF Parent;

      [Key, Description (
          "The child Product in the association.") ]
   CIM_Product REF Child;
};


// ==================================================================
// cim_realizesextent
// ==================================================================
   [Association, Version ("2.6.0"), Description (
       "StorageExtents can be realized by PhysicalComponents.  For "
       "example, disks or tapes are realized by PhysicalMedia.  Memory "
       "is realized by PhysicalMemory.  This relationship of Extents "
       "to PhysicalComponents is made explicit by the RealizesExtent "
       "association.  In addition, the StartingAddress of the "
       "StorageExtent on the Component is specified here.") ]
class CIM_RealizesExtent : CIM_Realizes {

      [Override ("Antecedent"), Max (1), Description (
          "The PhysicalComponent on which the Extent is realized.") ]
   CIM_PhysicalComponent REF Antecedent;

      [Override ("Dependent"), Description (
          "The StorageExtent that is located on the Component.") ]
   CIM_StorageExtent REF Dependent;

      [Description (
          "The starting address on the PhysicalComponent where the "
          "StorageExtent begins.  Ending address of the StorageExtent "
          "is determined using the NumberOfBlocks and Block Size "
          "properties of the StorageExtent object.") ]
   uint64 StartingAddress;
};


// ==================================================================
// cim_sapavailableforelement
// ==================================================================
   [Association, Version ( "2.8.0" ), Description (
       "CIM_SAPAvailableForElement conveys the semantics of a Service "
       "Access Point being available for a ManagedElement.  When "
       "CIM_SAPAvailableForElement is not instantiated then the SAP is "
       "assumed to be generally available.  If instantiated, the SAP "
       "is only available for the associated ManagedElements.  For "
       "example, a device might provide management access through a "
       "URL.  This association allows the URL to be advertised for the "
       "device.")]
class CIM_SAPAvailableForElement {

      [Key, Description (
          "The Service Access Point that is available.")]
   CIM_ServiceAccessPoint REF AvailableSAP;

      [Key, Description (
          "The ManagedElement for which the SAP is available.")]
   CIM_ManagedElement REF ManagedElement;
};


// ==================================================================
// cim_installedsoftwareidentity
// ==================================================================
   [Association, Version ( "2.8.0" ), Description (
       "The InstalledSoftwareIdentity association identifies the "
       "System on which a SoftwareIdentity is installed.  This class "
       "is a corollary to InstalledSoftwareElement, but deals with the "
       "asset aspects of software (as indicated by SoftwareIdentity), "
       "versus the deployment aspects (as indicated by "
       "SoftwareElement).")]
class CIM_InstalledSoftwareIdentity {

      [Key, Description (
          "The system on which the software is installed.")]
   CIM_System REF System;

      [Key, Description (
          "The SoftwareIdentity that is installed.")]
   CIM_SoftwareIdentity REF InstalledSoftware;
};


// ==================================================================
// cim_storageconfigurationcapabilities
// ==================================================================
   [Version ( "2.8.0" ), Description (
       "A subclass of Capabilities that defines the Capabilities of a "
       "StorageConfigurationService.  An instance of "
       "StorageConfigurationCapabilities is associated with a "
       "StorageConfigurationService using ElementCapabilities.")]
class CIM_StorageConfigurationCapabilities : CIM_Capabilities {

      [Description (
          "Enumeration indicating what operations will be executed as "
          "asynchronous jobs.  If an operation is included in both "
          "this and SupportedSynchronousActions then the underlying "
          "implementation is indicating that it may or may not create "
          "a job."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10" }, 
       Values { "Storage Pool Creation", "Storage Pool Deletion",
          "Storage Pool Modification", "Storage Element Creation",
          "Storage Element Return", "Storage Element Modification",
          "Replica Creation", "Replica Modification",
          "Replica Attachment" }, 
       ModelCorrespondence { 
          "CIM_StorageConfigurationCapabilities.SupportedSynchronousActions" 
          }]
   uint16 SupportedAsynchronousActions[];

      [Description (
          "Enumeration indicating what operations will be executed "
          "without the creation of a job.  If an operation is included "
          "in both this and SupportedAsynchronousActions then the "
          "underlying instrumentation is indicating that it may or may "
          "not create a job."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10" }, 
       Values { "Storage Pool Creation", "Storage Pool Deletion",
          "Storage Pool Modification", "Storage Element Creation",
          "Storage Element Return", "Storage Element Modification",
          "Replica Creation", "Replica Modification",
          "Replica Attachment" }, 
       ModelCorrespondence { "CIM_StorageConfigurationCapabilities." 
          "SupportedAsynchronousActions" }]
   uint16 SupportedSynchronousActions[];

      [Description (
          "Enumeration indicating the type of storage elements that "
          "are supported by the associated "
          "StorageConfigurationService."), 
       ValueMap { "2", "3", "..", "0x8000..0xFFFF" }, 
       Values { "StorageVolume", "StorageExtent", "DMTF Reserved",
          "Vendor Specific" }, 
       ModelCorrespondence { "CIM_StorageConfigurationService." 
          "CreateOrModifyElementFromStoragePool.ElementType" }]
   uint16 SupportedStorageElementTypes[];

      [Description (
          "Enumeration indicating features supported by the "
          "StoragePool methods."), 
       ValueMap { "2", "3", "4", "..", "0x8000..0xFFFF" }, 
       Values { "InExtents", "Single InPool", "Multiple InPools",
          "DMTF Reserved", "Vendor Specific" }, 
       ModelCorrespondence { "CIM_StorageConfigurationService." 
          "CreateOrModifyStoragePool.InPools",
          "CIM_StorageConfigurationService." 
          "CreateOrModifyStoragePool.InExtents" }]
   uint16 SupportedStoragePoolFeatures[];

      [Description (
          "Enumeration indicating features supported by the Storage "
          "Element methods."), 
       ValueMap { "2", "3", "4", "5", "6", "7", "..",
       "0x8000..0xFFFF" }, 
       Values { "StorageExtent Creation", "StorageVolume Creation",
          "StorageExtent Modification", "StorageVolume Modification",
          "Single InPool", "Multiple InPools", "DMTF Reserved",
          "Vendor Specific" }, 
       ModelCorrespondence { "CIM_StorageConfigurationService." 
          "CreateOrModifyElementFromStoragePool.ElementType",
          "CIM_StorageConfigurationService." 
          "CreateOrModifyElementFromStoragePool.InPool" }]
   uint16 SupportedStorageElementFeatures[];

      [Description (
          "SupportedCopyTypes describes the replication capabilities "
          "supported by the associated StorageConfigurationServices.  "
          "Values are: \n"
          "Async: asynchronous copies may be created and maintained.  "
          "\nSync:synchronouscopiesmaybe created and maintained.  "
          "\nUnSyncAssoc:unsynchronizedcopiesmaybe created and "
          "maintained.  \n"
          "UnSyncUnAssoc: a 'straight copy' may be created."), 
       ValueMap { "2", "3", "4", "5", "..", "0x8000..0xFFFF" }, 
       Values { "Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
          "DMTF Reserved", "Vendor Specific" }, 
       ModelCorrespondence { 
          "CIM_StorageConfigurationService.CreateReplica.CopyType" }]
   uint16 SupportedCopyTypes[];

      [Description (
          "InitialReplicationState specifies which initial "
          "ReplicationState is supported by a particular provider.  "
          "Values are: \n"
          "Initialized: The replication relationship is known and "
          "unsynchronized, but time required to synchronize may be "
          "long.  \n"
          "Prepared: The replication relationship is known and "
          "unsynchronized and the time required to synchronize will be "
          "short.  \n"
          "Synchronized: The replicas are synchronized."), 
       ValueMap { "2", "3", "4", "..", "0x8000..0xFFFF" }, 
       Values { "Initialized", "Prepared", "Synchronized",
          "DMTF Reserved", "Vendor Specific" }, 
       ModelCorrespondence { 
          "CIM_StorageConfigurationService.AttachReplica",
          "CIM_StorageConfigurationService.CreateReplica" }]
   uint16 InitialReplicationState;
};


// ==================================================================
// cim_storagesettingwithhints
// ==================================================================
   [Version ("2.7.1"), Description (
       "This subclass of StorageSetting allows a client to specify "
       "'hint's for optimization of the volume performance.  The "
       "effect of these hints is implementation dependent.") ]
class CIM_StorageSettingWithHints: CIM_StorageSetting {

      [Description (
          "This hint is an indication from a client of the importance "
          "placed on data availability.  Values are 0=Don't Care to "
          "10=Very Important."), 
       MinValue (0), MaxValue (10) ]
   uint16 DataAvailabilityHint;

      [Description (
          "This hint is an indication from a client of the randomness "
          "of accesses.  Values are 0=Entirely Sequential to "
          "10=Entirely Random."), 
       MinValue (0), MaxValue (10) ]
   uint16 AccessRandomnessHint;

      [Description (
          "This hint is an indication from a client of the direction "
          "of accesses.  Values are 0=Entirely Read to 10=Entirely "
          "Write."), 
       MinValue (0), MaxValue (10) ]
   uint16 AccessDirectionHint;

      [Description (
          "This hint is an indication from a client of the optimal "
          "access sizes (in bytes).  Since this property is an array, "
          "several sizes can be specified."), 
       Units ("Bytes") ]
   uint16 AccessSizeHint[];

      [Description (
          "This hint is an indication from a client how important "
          "access latency is.  Values are 0=Don't Care to 10=Very "
          "Important."), 
       MinValue (0), MaxValue (10) ]
   uint16 AccessLatencyHint;

      [Description (
          "This hint is an indication from a client of bandwidth "
          "prioritization.  Values are 0=Don't Care to 10=Very "
          "Important."), 
       MinValue (0), MaxValue (10) ]
   uint16 AccessBandwidthWeight;

      [Description (
          "This hint is an indication of the importance the client "
          "places on the cost of storage.  Values are 0=Don't Care to "
          "10=Very Important.  A StorageVolume provider might choose "
          "to place data on low cost or high cost drives based on this "
          "parameter."), 
       MinValue (0), MaxValue (10) ]
   uint16 StorageCostHint;

      [Description (
          "This hint is an indication of the importance placed on "
          "storage space efficiency by the client.  Values are 0=Don't "
          "Care to 10=Very Important.  A StorageVolume provider might "
          "choose different RAID levels based on this hint."), 
       MinValue (0), MaxValue (10) ]
   uint16 StorageEfficiencyHint;
};


// ==================================================================
// RegisteredSubProfile
// ==================================================================
   [Version ( "2.8.0" ), Description (
       "A RegisteredSubProfile subclasses RegisteredProfile to "
       "indicate that a scoping profile is required to provide "
       "context.  The latter is specified by the mandatory "
       "association, SubProfileRequiresProfile.")]
class CIM_RegisteredSubProfile : CIM_RegisteredProfile {
};


// ==================================================================
// SubProfileRequiresProfile
// ==================================================================
   [Association, Version ( "2.8.0" ), Description (
       "A subprofile requires another RegisteredProfile for context.  "
       "This association mandates the scoping relationship between a "
       "subprofile and its scoping profile.")]
class CIM_SubProfileRequiresProfile : CIM_ReferencedProfile {

      [Override ( "Antecedent" ), Min ( 1 ), Description (
          "The RegisteredProfile that is referenced/required by the "
          "subprofile.")]
   CIM_RegisteredProfile REF Antecedent;

      [Override ( "Dependent" ), Description (
          "A RegisteredSubProfile that requires a scoping profile, for "
          "context.")]
   CIM_RegisteredSubProfile REF Dependent;
};


// ==================================================================
// ProtocolAdapter
// ==================================================================
   [Deprecated { "CIM_ObjectManagerAdapter" }, Version ( "2.8.0" ), 
    Description (
       "CIM_ProtocolAdapter is deprecated in lieu of "
       "CIM_ObjectManagerAdapter.  Since the CIM_ProtocolAdapter class "
       "does not have to support the protocols and can be any type of "
       "adapter, it was decided to change the name to "
       "ObjectManagerAdapter to better reflect the true meaning of the "
       "class.  A ProtocolAdapter is a Service of the CIM Object "
       "Manager.  It is responsible for accepting incoming requests on "
       "a particular protocol, and translating and forwarding the "
       "request to the CIM Object Manager.  It is also responsible for "
       "translating and sending the response from the CIM Object "
       "Manager.")]
class CIM_ProtocolAdapter : CIM_WBEMService {

      [Deprecated { "CIM_ObjectManagerAdapter.Name" },
          Override ( "Name" ), Description (
          "A human-readable name that uniquely identifies the Protocol "
          "Adapter within a system.")]
   string Name;

      [Deprecated { "CIM_ObjectManagerAdapter.Handle" }, Required, 
       Description (
          "An implementation specific string that identifies the "
          "handle to the ProtocolAdapter.")]
   string Handle;

      [Deprecated { "CIM_ObjectManagerAdapter.AdapterType" }, Required, 
       Description (
          "ProtocolAdapterType enumerates the kind of Protocol "
          "Adapter."), 
       ValueMap { "1", "2", "3" }, 
       Values { "Other", "Client", "Provider" }, 
       ModelCorrespondence { 
          "CIM_ProtocolAdapter.OtherProtocolAdapterType" }]
   uint16 ProtocolAdapterType;

      [Deprecated { 
          "CIM_ObjectManagerAdapter.OtherAdapterTypeDescription" }, 
       Description (
          "The type(s) of ProtocolAdapter when \"Other\" is included "
          "in ProtocolAdapterType property."), 
       ModelCorrespondence { "CIM_ProtocolAdapter.ProtocolAdapterType" 
          }]
   string OtherProtocolAdapterType;
};

// ==================================================================
// CommMechanismForAdapter
// ==================================================================
   [Association, Version ("2.7.0"), Description (
       "CommMechanismForAdapter is an association between an "
       "ObjectManager's communication mechanism and a ProtocolAdapter "
       "that supports that mechanism to translate requests and "
       "responses for the Object Manager.") ]
class CIM_CommMechanismForAdapter : CIM_Dependency {

      [Override ("Antecedent"), Description (
          "The specific ProtocolAdapter whose communication mechanism "
          "with the CIM Object Manager is described.") ]
   CIM_ProtocolAdapter REF Antecedent;

      [Override ("Dependent"), Min (1), Description (
          "The encoding/protocol/set of operations that may be used to "
          "communicate between the Object Manager and the referenced "
          "ProtocolAdapter.") ]
   CIM_ObjectManagerCommunicationMechanism REF Dependent;
};


// ==================================================================
// ProviderCapabilities
// ==================================================================
   [Experimental, Version ( "2.7.1000"), Description (
       "This class defines the capabilities of the associated "
       "provider.") ]
class CIM_ProviderCapabilities : CIM_Capabilities {

      [Required, Description (
          "The ClassName lists the class for which the associated "
          "Provider supplies instances, associations or indications "
          "information.  The ClassInNamespace association provides "
          "namespace information for the listed class name.") ]
   string ClassName;

      [Description (
          "ProviderType enumerates the kind of provider capabilities "
          "defined for the associated Provider."), 
       ValueMap { "1", "2", "3", "4", "5"}, 
       Values { "Other", "Instance", "Association", "Indication",
          "Method"}, 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { 
          "CIM_ProviderCapabilities.OtherProviderType"} ]
   uint16 ProviderTypes[];

      [Description (
          "Type(s) of provider capability when \"Other\" is included "
          "in ProviderType property array."), 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { "CIM_ProviderCapabilities.ProviderType"} ]
   string OtherProviderTypes[];

      [Description (
          "SupportedProperties lists the properties supported by this "
          "provider.  If this array is NULL, the provider MUST support "
          "all of the properties defined in the class.  If the "
          "provider does not support all of the properties, the "
          "properties supported MUST be included in the array.  The "
          "array entry format is \"PropertyName\".") ]
   string SupportedProperties[];

      [Description (
          "SupportedMethods lists the methods supported by this "
          "provider.  If this array is NULL, the provider MUST support "
          "all the methods defined in the class.  If the provider does "
          "not support all the methods, the methods supported MUST be "
          "included in the array.  The array entry format is "
          "\"MethodName\".") ]
   string SupportedMethods[];
};

// ==================================================================
// ProviderElementCapabilities
// ==================================================================
   [Association, Experimental, Version ( "2.7.1000"), Description (
       "ProviderElementCapabilities is an association describing the "
       "Capabilities that are supported by a Provider.") ]
class CIM_ProviderElementCapabilities : CIM_ElementCapabilities {

      [Override ( "ManagedElement"), Min ( 1), Max ( 1), Description (
          "The CIM Provider.") ]
   CIM_Provider REF ManagedElement;

      [Override ( "Capabilities"), Description (
          "The CIM Provider's Capabilities.") ]
   CIM_ProviderCapabilities REF Capabilities;
};

// ==================================================================
// ClassSupportForNamespace
// ==================================================================
   [Association, Experimental, Version ( "2.7.1000"), Description (
       "ClassSupportForNamespace is an association describing the "
       "target Namespace for the instances of the class listed in the "
       "referenced ProviderCapabilities.ClassName property.") ]
class CIM_ClassSupportForNamespace : CIM_Dependency {

      [Override ( "Antecedent"), Description (
          "The Namespace in which the class instances are defined.") ]
   CIM_Namespace REF Antecedent;

      [Override ( "Dependent"), Description (
          "The ProviderCapabilities instance supporting the class "
          "instances.") ]
   CIM_ProviderCapabilities REF Dependent;
};

// ==================================================================
// ProviderModule
// ==================================================================
   [Experimental, Version ( "2.7.1000"), Description (
       "A ProviderModule consists of one or more Provider Services.  "
       "It can be enabled/disabled - which affects the component "
       "Services.") ]
class CIM_ProviderModule : CIM_EnabledLogicalElement {

      [Key, Override ( "Name"), Description (
          "A human-readable name that uniquely identifies the Provider "
          "Module.  Name is chosen as one of the keys for "
          "correspondence with the keys/identity of the component "
          "Provider Services.") ]
   string Name;

      [Required, Description (
          "An implementation specific string that identifies the "
          "handle of the provider.") ]
   string Handle;
};

// ==================================================================
// ProviderInModule
// ==================================================================
   [Association, Experimental, Aggregation, Composition,
       Version ( "2.7.1000"), Description (
       "An association describing the Providers that are contained in "
       "a ProviderModule.") ]
class CIM_ProviderInModule : CIM_Component {

      [Aggregate, Override ( "GroupComponent"), Max ( 1), Description (
          "The CIM ProviderModule.") ]
   CIM_ProviderModule REF GroupComponent;

      [Override ( "PartComponent"), Description (
          "The CIM Providers.") ]
   CIM_Provider REF PartComponent;
};

// ==================================================================
// FiltersSupported
// ==================================================================
   [Association, Experimental, Version ( "2.7.1000"), Description (
       "FiltersSupported is an association describing the CIM "
       "IndicationFilters that are supported by a Provider.") ]
class CIM_FiltersSupported : CIM_Dependency {

      [Override ( "Antecedent"), Description (
          "The CIM IndicationFilter supported for the CIM classes "
          "listed in ClassNames array property of the referenced "
          "ProviderCapabilities instance.") ]
   CIM_IndicationFilter REF Antecedent;

      [Override ( "Dependent"), Description (
          "The CIM Provider Capabilities.") ]
   CIM_ProviderCapabilities REF Dependent;
};


// ===================================================================
// AffectedJobElement
// ===================================================================
   [Association, Version ( "2.7.0"), Description (
       "AffectedJobElement represents an association between a Job and "
       "the ManagedElement(s) that may be affected by its execution.  "
       "It may not be feasible for the Job to describe all of the "
       "affected elements.  The main purpose of this association is to "
       "provide information when a Job requires exclusive use of the "
       "'affected' ManagedElment(s) or when describing that side "
       "effects may result.") ]
class CIM_AffectedJobElement {

      [Key, Description (
          "The ManagedElement affected by the execution of the Job.") ]
   CIM_ManagedElement REF AffectedElement;

      [Key, Description (
          "The Job that is affecting the ManagedElement.") ]
   CIM_Job REF AffectingElement;

      [Description (
          "An enumeration describing the 'effect' on the "
          "ManagedElement.  This array corresponds to the "
          "OtherElementEffectsDescriptions array, where the latter "
          "provides details related to the high-level 'effects' "
          "enumerated by this property.  Additional detail is required "
          "if the ElementEffects array contains the value 1, "
          "\"Other\"."), 
       ValueMap { "0", "1", "2", "3", "4"}, 
       Values { "Unknown", "Other", "Exclusive Use",
          "Performance Impact", "Element Integrity"}, 
       ArrayType ( "Indexed"), 
       ModelCorrespondence { 
          "CIM_AffectedJobElement.OtherElementEffectsDescriptions"} ]
   uint16 ElementEffects[];

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



// ===================================================================
// OwningJobElement
// ===================================================================
   [Association, Version ( "2.7.0"), Description (
       "OwningJobElement represents an association between a Job and "
       "the ManagedElement responsible for the creation of the Job.  "
       "This association may not be possible, given that the execution "
       "of jobs can move between systems and that the lifecycle of the "
       "creating entity may not persist for the total duration of the "
       "job.  However, this can be very useful information when "
       "available.  This association defines a more specific 'owner' "
       "than is provided by the CIM_Job.Owner string."), 
    ModelCorrespondence { "CIM_Job.Owner"} ]
class CIM_OwningJobElement {

      [Key, Max ( 1), Description (
          "The ManagedElement responsible for the creation of the "
          "Job.") ]
   CIM_ManagedElement REF OwningElement;

      [Key, Description (
          "The Job created by the ManagedElement.") ]
   CIM_Job REF OwnedElement;
};

// ===================================================================
// AssociatedProtocolController
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "This association is used to define a hierarchy relationship "
       "between ProtocolControllers.  This subclass is provided so "
       "that an enumeration of related ProtocolControllers can be "
       "performed without retrieving any connected StorageVolumes, "
       "MediaAccessDevices or LogicalPorts.")]
class CIM_AssociatedProtocolController : CIM_ProtocolControllerForDevice {

      [Override ( "Antecedent" ), Description (
          "The 'upstream', Antecedent ProtocolController.")]
   CIM_ProtocolController REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The 'downstream' Dependent ProtocolController.")]
   CIM_ProtocolController REF Dependent;
};

// ===================================================================
// CredentialManagementService
// ===================================================================
   [Version ( "2.6.0" ), Description (
       "CIM_CredentialManagementService issues credentials and manages "
       "the credential lifecycle.")]
class CIM_CredentialManagementService : CIM_AuthenticationService {
};


// ===================================================================
// CertificateAuthority
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A Certificate Authority (CA) is a credential management "
       "service that issues and cryptographically signs certificates. "
       "It acts as an trusted third-party intermediary in establishing "
       "trust relationships. The CA authenticates the identity of the "
       "holder of the 'private' key, related to the certificate's "
       "'public' key.")]
class CIM_CertificateAuthority : CIM_CredentialManagementService {

      [Description (
          "The CAPolicyStatement describes what care is taken by the "
          "CertificateAuthority when signing a new certificate. The "
          "CAPolicyStatment may be a dot-delimited ASN.1 OID string "
          "which identifies to the formal policy statement.")]
   string CAPolicyStatement;

      [Description (
          "A CRL, or CertificateRevocationList, is a list of "
          "certificates which the CertificateAuthority has revoked and "
          "which are not yet expired. Revocation is necessary when the "
          "private key associated with the public key of a certificate "
          "is lost or compromised, or when the person for whom the "
          "certificate is signed no longer is entitled to use the "
          "certificate."), 
       OctetString]
   string CRL[];

      [Description (
          "Certificate revocation lists may be available from a number "
          "of distribution points. CRLDistributionPoint array values "
          "provide URIs for those distribution points.")]
   string CRLDistributionPoint[];

      [Description (
          "Certificates refer to their issuing CA by its Distinguished "
          "Name (as defined in X.501)."), 
       Dn]
   string CADistinguishedName;

      [Description (
          "The frequency, expressed in hours, at which the CA will "
          "update its Certificate Revocation List. Zero implies that "
          "the refresh frequency is unknown."), 
       Units ( "Hours" )]
   uint8 CRLRefreshFrequency;

      [Description (
          "The maximum number of certificates in a certificate chain "
          "permitted for credentials issued by this certificate "
          "authority or it's subordinate CAs. \n"
          "The MaxChainLength of a superior CA in the trust hierarchy "
          "should be greater than this value and the MaxChainLength of "
          "a subordinate CA in the trust hierarchy should be less than "
          "this value.")]
   uint8 MaxChainLength;
};

// ===================================================================
// Credential
// ===================================================================
   [Abstract, Version ( "2.8.0" ), Description (
       "Subclasses of CIM_Credential define materials, information or "
       "other data which are used to establish identity. Generally, "
       "there may be some shared information, or credential material "
       "which is used to identify and authenticate an entity in the "
       "process of gaining access to, or permission to use, resources. "
       "Such credential material may be used to authenticate an "
       "entity's identity initially, as done by a "
       "CIM_AuthenticationService, and additionally on an ongoing "
       "basis (for example, during the course of a connection or other "
       "security association), as proof that each received message or "
       "communication came from a valid 'user' of that credential "
       "material.")]
class CIM_Credential : CIM_ManagedElement {

      [Description (
          "The date and time when the credential was issued. Use a "
          "value of all 0s if this information is not applicable.")]
   datetime Issued;

      [Description (
          "The date and time when the credential expires (and is not "
          "appropriate for use for authentication/ authorization). Use "
          "a value of all 9s if this information is not applicable. "
          "Note that this property does not define how the expiration "
          "is set - but that there IS an expiration. The property may "
          "be set to either a specific date/time or an interval "
          "(calculated from the Issued datetime). For example, for "
          "Certificate Authority-signed public key, the expiration is "
          "determined by the CA. Another example is a voice mail "
          "password that expires 60 days after it is set/issued.")]
   datetime Expires;
};


// ===================================================================
// PublicKeyCertificate
// ===================================================================
   [Version ( "2.8.0" ), Description (
       "A PublicKeyCertificate is a credential that is "
       "cryptographically signed by a trusted Certificate Authority "
       "(CA) and issued to an authenticated entity (e.g., human user, "
       "service, etc.) called the Subject in the certificate. The "
       "public key in the certificate is cryptographically related to "
       "a private key that is held and kept private by the "
       "authenticated Subject. The certificate and its related private "
       "key can then be used for establishing trust relationships and "
       "securing communications with the Subject. Refer to the "
       "ITU/CCITT X.509 standard as an example of such certificates.")]
class CIM_PublicKeyCertificate : CIM_Credential {

      [Key,
          Propagated ( "CIM_CertificateAuthority.SystemCreationClassName" 
          ), Description (
          "The scoping System's CCN."), 
       MaxLen ( 256 )]
   string SystemCreationClassName;

      [Key, Propagated ( "CIM_CertificateAuthority.SystemName" ), 
       Description (
          "The scoping System's Name."), 
       MaxLen ( 256 )]
   string SystemName;

      [Key, Propagated ( "CIM_CertificateAuthority.CreationClassName" ), 
       Description (
          "The scoping Service's CCN."), 
       MaxLen ( 256 )]
   string ServiceCreationClassName;

      [Key, Propagated ( "CIM_CertificateAuthority.Name" ), 
       Description (
          "The scoping Service's Name."), 
       MaxLen ( 256 )]
   string ServiceName;

      [Key, Description (
          "Certificate subject identifier."), 
       MaxLen ( 256 )]
   string Subject;

      [Description (
          "Alternate subject identifier for the Certificate."), 
       MaxLen ( 256 )]
   string AltSubject;

      [Description (
          "The DER-encoded raw public key."), 
       OctetString]
   uint8 PublicKey[];
};















// ===================================================================
// IBMTS_Account
// ===================================================================
[  // Provider("com.ibm.provider.security.SecurityProvider"),
	Description("User Account on the CIMOM"), AccessRole("None") ]
class IBMTS_Account : CIM_Account
{
	/* ManagedElement */
	[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (64), Description (
			"The Caption property is a short textual description (one-"
			"line string) of the object.") ]
	string Caption;
	
	/* ManagedElement */
	[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Description property provides a textual description of "
			"the object.") ]
	string Description;
	
	/* ManagedElement */
	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"  A user-friendly name for the object. This property allows "
			"each instance to define a user-friendly name IN ADDITION TO its "
			"key properties/identity data, and description information. \n"
			"  Note that ManagedSystemElement's Name property is also defined "
			"as a user-friendly name. But, it is often subclassed to be a "
			"Key. It is not reasonable that the same property can convey "
			"both identity and a user friendly name, without inconsistencies. "
			"Where Name exists and is not a Key (such as for instances of "
			"LogicalDevice), the same information MAY be present in both "
			"the Name and ElementName properties.") ]
	string ElementName;
	
	/* ManagedSystemElement */
	[Override("InstallDate"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A datetime value indicating when the object was installed. "
			"A lack of a value does not indicate that the object is not "
			"installed.") ]
	datetime InstallDate;
	
//	/* ManagedSystemElement */
//	[Override("Name"), Provider("com.ibm.provider.security.SecurityProvider"),
//		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;
// Override by Account

	/* ManagedSystemElement */
	[Override("OperationalStatus"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description (
			"   Indicates the current status(es) of the element. "
			"Various health and operational statuses are "
			"defined. Many of the enumeration's values are self-"
			"explanatory.  However, a few are not and are described "
			"in more detail. \n"
			"  \"Stressed\" indicates that the element is functioning, "
			"but needs attention. Examples of \"Stressed\" states are "
			"overload, overheated, etc. \n"
			"  \"Predictive Failure\" indicates that an element is "
			"functioning nominally but predicting a failure in the "
			"near future. \n"
			"  \"In Service\" describes an element being configured, "
			"maintained, cleaned, or otherwise administered. \n"
			"  \"No Contact\" indicates that the monitoring system "
			"has knowledge of this element, but has never been able to "
			"establish communications with it. \n"
			"  \"Lost Communication\" indicates that the ManagedSystem"
			"Element is known to exist and has been contacted "
			"successfully in the past, but is currently unreachable. \n"
			"  \"Stopped\" and \"Aborted\" are similar, although the "
			"former implies a clean and orderly stop, while the latter "
			"implies an abrupt stop where the element's state and "
			"configuration may need to be updated. \n"
			"\"Dormant\" indicates that the element is inactive or "
			"quiesced. \n"
			"  \"Supporting Entity in Error\" describes that this "
			"element may be \"OK\" but that another element, on which it "
			"is dependent, is in error. An example is a network service "
			"or endpoint that cannot function due to lower layer "
			"networking problems. \n"
			"\"Completed\" indicates the element has completed its "
			"operation.  This value should be combined with either OK, "
			"Error, or Degraded so that a client can till if the complete "
			"operation passed (Completed with OK), and failure (Completed "
			"with Error).  Completed with Degraded would imply the "
			"operation finished, but did not complete OK or report an "
			"error. \n"
			"  OperationalStatus replaces the Status property on "
			"ManagedSystemElement to provide a consistent approach to "
			"enumerations, to address implementation needs for an "
			"array property, and to provide a migration path from today's "
			"environment to the future. This change was not made earlier "
			"since it required the DEPRECATED qualifier. Due to the "
			"widespread use of the existing Status property in "
			"management applications, it is strongly recommended that "
			"providers/instrumentation provide BOTH the Status and "
			"OperationalStatus properties. As always, Status (since it "
			"is single-valued) provides the primary status of the "
			"element."),
		ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8",
			"9", "10", "11", "12", "13", "14", "15", "16", "17",
			"18"},
		Values {"Unknown", "Other", "OK", "Degraded", "Stressed",
			"Predictive Failure", "Error", "Non-Recoverable Error",
			"Starting", "Stopping", "Stopped", "In Service",
			"No Contact", "Lost Communication", "Aborted",
			"Dormant", "Supporting Entity in Error", "Completed",
			"Power Mode"},
		ArrayType ("Indexed"),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.StatusDescriptions"} ]
	uint16 OperationalStatus[];
	
	/* ManagedSystemElement */
	[Override("StatusDescriptions"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description (
			"A string describing the status - used when the "
			"OperationalStatus property is set to 1 (\"Other\")."),
		ArrayType ("Indexed"),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.OperationalStatus"} ]
	string StatusDescriptions[];
	
	/* ManagedSystemElement */
	[Override("Status"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (10),
		Deprecated {"CIM_ManagedSystemElement.OperationalStatus"},
		Description (
			"A string indicating the current status of the object. "
			"Various operational and non-operational statuses are "
			"defined. This property is deprecated in lieu of "
			"OperationalStatus, which includes the same semantics "
			"in its enumeration. This change is made for 3 reasons: "
			"1) Status is more correctly defined as an array. "
			"This overcomes the limitation of describing status via a "
			"single value, when it is really a multi-valued property "
			"(for example, an element may be OK AND Stopped. 2) A "
			"MaxLen of 10 is too restrictive and leads to unclear "
			"enumerated values. And, 3) The change to a uint16 data "
			"type was discussed when CIM V2.0 was defined. However, "
			"existing V1.0 implementations used the string property "
			"and did not want to modify their code. Therefore, Status "
			"was grandfathered into the Schema. Use of the Deprecated "
			"qualifier allows the maintenance of the existing "
			"property, but also permits an improved definition using "
			"OperationalStatus."),
		ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail",
			"Starting", "Stopping", "Service", "Stressed",
			"NonRecover", "No Contact", "Lost Comm", "Stopped"} ]
	string Status;
	
	/* Account */
	[Override("SystemCreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Propagated ("CIM_System.CreationClassName"), Key,
		MaxLen (256), Description ("The scoping System's CCN."), ReadRole("None") ]
	string SystemCreationClassName;
	
	/* Account */
	[Override("SystemName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Propagated ("CIM_System.Name"), Key,
		MaxLen (256),Description ("The scoping System's Name."), ReadRole("None") ]
	string SystemName;
	
	/* Account */
	[Override("CreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		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."), ReadRole("None") ]
	string CreationClassName;
	
	/* Account */
	[Override("Name"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, MaxLen (1024), Description (
			"The Name property defines the label by which the object is "
			"known.  The value of this property may be set to be the same "
			"as that of the UserID property or, in the case of an "
			"LDAP-derived instance, the Name property value may be set to "
			"the distinguishedName of the LDAP-accessed object instance."), ReadRole("None") ]
	string Name;
	
	/* Account */
	[Override("UserID"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (256), Description (
			"UserID is the value used by the SecurityService to "
			"represent identity.  For an authentication service, the "
			"UserID may be the name of the user, or for an authorization "
			"service the value which serves as a handle to a mapping of "
			"the identity.") ]
	string UserID;
	
	/* Account */
	[Override("ObjectClass"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"In the case of an LDAP-derived instance, the ObjectClass "
			"property value(s) may be set to the objectClass attribute "
			"values.") ]
	string ObjectClass[];
	
	/* Account */
	[Override("Descriptions"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (1024), Description (
			"The Descriptions property values may contain human-readable "
			"descriptions of the object.  In the case of an LDAP-derived "
			"instance, the description attribute may have multiple values "
			"that, therefore, cannot be placed in the inherited "
			"Description property.") ]
	string Descriptions[];
	
	/* Account */
	[Override("Host"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Based on RFC1274, the host name of the system(s) for which "
			"the account applies.  The host name may be a fully-qualified "
			"DNS name or it may be an unqualified host name.") ]
	string Host[];
	
	/* Account */
	[Override("LocalityName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This property contains the name of a locality, such as a "
			"city, county or other geographic region.") ]
	string LocalityName[];
	
	/* Account */
	[Override("OrganizationName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Required, Description (
			"The name of the organization related to the account.") ]
	string OrganizationName[];
	
	/* Account */
	[Override("OU"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The name of an organizational unit related to the account.") ]
	string OU[];
	
	/* Account */
	[Override("SeeAlso"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"In the case of an LDAP-derived instance, the See Also "
			"property specifies distinguishedName of other Directory "
			"objects which may be other aspects (in some sense) of the "
			"same real world object.") ]
	string SeeAlso[];
	
	/* Account */
	[Override("UserCertificate"), Provider("com.ibm.provider.security.SecurityProvider"),
		Octetstring, Description (
			"Based on inetOrgPerson and for directory compatibility, the "
			"User Certificate property may be used to specify a public key "
			"certificate for the person.") ]
	string UserCertificate[];
	
	/* Account */
	[Override("UserPassword"), Provider("com.ibm.provider.security.SecurityProvider"),
		Octetstring, Description (
			"In the case of an LDAP-derived instance, the UserPassword "
			"property may contain an encrypted password used to access "
			"the person's resources in a directory.") ]
	string UserPassword[];
	
};

// =================================================================================
// IBMTS_AccountManagementService
// =================================================================================
[  Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Manages Accounts for the CIMOM."), AccessRole("None") ]
class IBMTS_AccountManagementService : CIM_AccountManagementService
{
	/* ManagedElement */
	[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (64), Description (
			"The Caption property is a short textual description (one-"
			"line string) of the object."), ReadRole("None") ]
	string Caption;
	
	/* ManagedElement */
	[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Description property provides a textual description of "
			"the object."), ReadRole("None") ]
	string Description;
	
	/* ManagedElement */
	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"  A user-friendly name for the object. This property allows "
			"each instance to define a user-friendly name IN ADDITION TO its "
			"key properties/identity data, and description information. \n"
			"  Note that ManagedSystemElement's Name property is also defined "
			"as a user-friendly name. But, it is often subclassed to be a "
			"Key. It is not reasonable that the same property can convey "
			"both identity and a user friendly name, without inconsistencies. "
			"Where Name exists and is not a Key (such as for instances of "
			"LogicalDevice), the same information MAY be present in both "
			"the Name and ElementName properties."), ReadRole("None") ]
	string ElementName;
	
	/* ManagedSystemElement */
	[Override("InstallDate"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A datetime value indicating when the object was installed. "
			"A lack of a value does not indicate that the object is not "
			"installed.") ]
	datetime InstallDate;
	
//	/* ManagedSystemElement */
//	[Override("Name"), Provider("com.ibm.provider.security.SecurityProvider"),
//		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;
// Override by Service

	/* ManagedSystemElement */
	[Override("OperationalStatus"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description (
			"   Indicates the current status(es) of the element. "
			"Various health and operational statuses are "
			"defined. Many of the enumeration's values are self-"
			"explanatory.  However, a few are not and are described "
			"in more detail. \n"
			"  \"Stressed\" indicates that the element is functioning, "
			"but needs attention. Examples of \"Stressed\" states are "
			"overload, overheated, etc. \n"
			"  \"Predictive Failure\" indicates that an element is "
			"functioning nominally but predicting a failure in the "
			"near future. \n"
			"  \"In Service\" describes an element being configured, "
			"maintained, cleaned, or otherwise administered. \n"
			"  \"No Contact\" indicates that the monitoring system "
			"has knowledge of this element, but has never been able to "
			"establish communications with it. \n"
			"  \"Lost Communication\" indicates that the ManagedSystem"
			"Element is known to exist and has been contacted "
			"successfully in the past, but is currently unreachable. \n"
			"  \"Stopped\" and \"Aborted\" are similar, although the "
			"former implies a clean and orderly stop, while the latter "
			"implies an abrupt stop where the element's state and "
			"configuration may need to be updated. \n"
			"\"Dormant\" indicates that the element is inactive or "
			"quiesced. \n"
			"  \"Supporting Entity in Error\" describes that this "
			"element may be \"OK\" but that another element, on which it "
			"is dependent, is in error. An example is a network service "
			"or endpoint that cannot function due to lower layer "
			"networking problems. \n"
			"\"Completed\" indicates the element has completed its "
			"operation.  This value should be combined with either OK, "
			"Error, or Degraded so that a client can till if the complete "
			"operation passed (Completed with OK), and failure (Completed "
			"with Error).  Completed with Degraded would imply the "
			"operation finished, but did not complete OK or report an "
			"error. \n"
			"  OperationalStatus replaces the Status property on "
			"ManagedSystemElement to provide a consistent approach to "
			"enumerations, to address implementation needs for an "
			"array property, and to provide a migration path from today's "
			"environment to the future. This change was not made earlier "
			"since it required the DEPRECATED qualifier. Due to the "
			"widespread use of the existing Status property in "
			"management applications, it is strongly recommended that "
			"providers/instrumentation provide BOTH the Status and "
			"OperationalStatus properties. As always, Status (since it "
			"is single-valued) provides the primary status of the "
			"element."),
		ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8",
			"9", "10", "11", "12", "13", "14", "15", "16", "17",
			"18"},
		Values {"Unknown", "Other", "OK", "Degraded", "Stressed",
			"Predictive Failure", "Error", "Non-Recoverable Error",
			"Starting", "Stopping", "Stopped", "In Service",
			"No Contact", "Lost Communication", "Aborted",
			"Dormant", "Supporting Entity in Error", "Completed",
			"Power Mode"},
		ArrayType ("Indexed"),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.StatusDescriptions"} ]
	uint16 OperationalStatus[];
	
	/* ManagedSystemElement */
	[Override("StatusDescriptions"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description (
			"A string describing the status - used when the "
			"OperationalStatus property is set to 1 (\"Other\")."),
		ArrayType ("Indexed"),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.OperationalStatus"} ]
	string StatusDescriptions[];
	
	/* ManagedSystemElement */
	[Override("Status"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (10),
		Deprecated {"CIM_ManagedSystemElement.OperationalStatus"},
		Description (
			"A string indicating the current status of the object. "
			"Various operational and non-operational statuses are "
			"defined. This property is deprecated in lieu of "
			"OperationalStatus, which includes the same semantics "
			"in its enumeration. This change is made for 3 reasons: "
			"1) Status is more correctly defined as an array. "
			"This overcomes the limitation of describing status via a "
			"single value, when it is really a multi-valued property "
			"(for example, an element may be OK AND Stopped. 2) A "
			"MaxLen of 10 is too restrictive and leads to unclear "
			"enumerated values. And, 3) The change to a uint16 data "
			"type was discussed when CIM V2.0 was defined. However, "
			"existing V1.0 implementations used the string property "
			"and did not want to modify their code. Therefore, Status "
			"was grandfathered into the Schema. Use of the Deprecated "
			"qualifier allows the maintenance of the existing "
			"property, but also permits an improved definition using "
			"OperationalStatus."),
		ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail",
			"Starting", "Stopping", "Service", "Stressed",
			"NonRecover", "No Contact", "Lost Comm", "Stopped"} ]
	string Status;
	
	/* EnabledLogicalElement */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"EnabledStatus is an integer enumeration indicating "
			"whether the element is currently shutting down (value = 4), "
			"or in an enabled (value = 2) or disabled (value = 3) "
			"state.  In various situations, an element that is being "
			"tested is neither enabled or disabled - this is addressed "
			"by the value \"In Test\" (7). It is possible that a "
			"particular instance of a LogicalDevice, SAP, etc. may not "
			"support being enabled/disabled. If this occurs, the value 5 "
			"(\"Not  Applicable\") is used."),
		ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
			"11..32767", "32768..65535" },
		Values {"Unknown", "Other", "Enabled", "Disabled",
			"Shutting Down", "Not Applicable", "Enabled but Offline",
			"In Test", "Deferred", "Quiesce", "Starting",
			"DMTF Reserved", "Vendor Reserved" },
		ModelCorrespondence {
			"CIM_EnabledLogicalElement.OtherEnabledState"} ]
	uint16 EnabledState = 5;
	
	/* EnabledLogicalElement */
	[Override("OtherEnabledState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A string describing the element's enabled/disabled state when "
			"the EnabledStatus property is set to 1 (\"Other\"). This "
			"property MUST be set to NULL when EnabledStatus "
			"is any value other than 1."),
		ModelCorrespondence {"CIM_EnabledLogicalElement.EnabledState"} ]
	string OtherEnabledState;
	
	/* EnabledLogicalElement */
	[Override("RequestedState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Write, Description (
			"RequestedStatus is an integer enumeration indicating "
			"whether the element should be shut down (value = 4), "
			"enabled (2), disabled (3), taken offline (6) or "
			"tested (7) at the next opportunity. This "
			"property is provided to compare Requested and "
			"current Enabled statuses. Note that when "
			"EnabledStatus is set to 5 (\"Not Applicable\"), "
			"then writing this property has no effect. By default, "
			"the element's RequestedStatus is 5 (\"No Change\")."),
		ModelCorrespondence  {"CIM_EnabledLogicalElement.EnabledState"},
		ValueMap {"2", "3", "4", "5", "6", "7", "8", "9",
			"10..32767", "32768..65535" },
		Values {"Enabled", "Disabled", "Shut Down", "No Change",
			"Offline", "Test", "Deferred", "Quiesce",
			"DMTF Reserved", "Vendor Reserved"} ]
	uint16 RequestedState = 5;
	
	/* EnabledLogicalElement */
	[Override("EnabledDefault"), Provider("com.ibm.provider.security.SecurityProvider"),
		Write, Description (
			"An enumerated value indicating an administrator's "
			"default/startup configuration for an element's Enabled"
			"Status. By default, the element is \"Enabled\" (value=2)."),
		ValueMap {"2", "3", "5", "6", "7", "8..32767",
			"32768..65535"},
		Values {"Enabled", "Disabled", "Not Applicable",
			"Enabled but Offline", "No Default",
			"DMTF Reserved", "Vendor Reserved"} ]
	uint16 EnabledDefault = 2;
	
	/* EnabledLogicalElement */
	[Override("TimeOfLastStateChange"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description("")]
	datetime TimeOfLastStateChange;
	
	/* EnabledLogicalElement */
	[Override("RequestStateChange"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description(""),
		ValueMap {"0", "1",
			"2", "3",
			"4", "5", "6", "..",
			"4096",
			"4097", "4098",
			"4099", "4100..32767", "32768..65535"},
		Values {"Completed with No Error", "Not Supported",
			"Unknown/Unspecified Error",
			"Can NOT complete within Timeout Period",
			"Failed", "Invalid Parameter", "In Use", "DMTF Reserved",
			"Method Parameters Checked - Job Started",
			"Invalid State Transition",
			"Use of Timeout Parameter Not Supported",
			"Busy", "Method Reserved", "Vendor Specific"},
		ModelCorrespondence  {"CIM_EnabledLogicalElement.RequestedState"}]
	uint32 RequestStateChange(
		[IN, Description
			("The state requested for the element. This "
				"information will be placed into the instance's "
				"RequestedState property if the RequestStateChange "
				"method's return code is 0, 3, or 4096 (0x1000) "
				"'Completed with No Error', 'Timeout', or 'Job "
				"Started' respectively. Refer to the description of "
				"the EnabledState property for the detailed meanings "
				"of the RequestedState Values."),
			ModelCorrespondence
			{"CIM_EnabledLogicalElement.RequestedState"},
			ValueMap {"2", "3", "4", "6", "7", "8", "9",
				"..", "32768..65535" },
			Values {"Enabled", "Disabled",
				"Shut Down", "Offline", "Test", "Defer", "Quiesce",
				"DMTF Reserved", "Vendor Reserved"}]
		uint16 RequestedState,
		[OUT, IN(false), Description
			("Reference to the job (may be null if task "
				"completed).") ]
		CIM_ConcreteJob REF Job,
		[IN, Description
			("A timeout period that specifies the maximum amount "
				"of time that the client expects the transition to "
				"the new state to take.  The interval format MUST be "
				"used to specify the TimeoutPeriod.  A value of 0 or "
				"a null parameter indicates that the client has no "
				"time requirements for the transition.\n"
				"If this property does not contain 0 or null and the "
				"implementation doesn't support this parameter.  A "
				"return code of 'Use Of Timeout Parameter Not "
				"Supported' MUST be returned.")]
		datetime TimeoutPeriod);
	
	/* Service */
	[Override("SystemCreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Propagated ("CIM_System.CreationClassName"), Key, MaxLen (256),
		Description (
			"The scoping System's CreationClassName."), ReadRole("None") ]
	string SystemCreationClassName;
	
	/* Service */
	[Override("SystemName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Propagated ("CIM_System.Name"), Key, MaxLen (256),
		Description (
			"The scoping System's Name."), ReadRole("None") ]
	string SystemName;
	
	/* Service */
	[Override("CreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		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."), ReadRole("None") ]
	string CreationClassName;
	
	/* Service */
	[Override("Name"), Provider("com.ibm.provider.security.SecurityProvider"),
		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."), ReadRole("None") ]
	string Name;
	
	/* Service */
	[Override("PrimaryOwnerName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, MaxLen (64), Write, Description (
			"The name of the primary owner for the service, if "
			"one is defined. The primary owner is the initial "
			"support contact for the Service.") ]
	string PrimaryOwnerName;
	
	/* Service */
	[Override("PrimaryOwnerContact"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, MaxLen (256), Write, Description (
			"A string that provides information on how the primary "
			"owner of the Service can be reached (e.g. phone "
			"number, email address, ...).") ]
	string PrimaryOwnerContact;
	
	/* Service */
	[Override("StartMode"), Provider("com.ibm.provider.security.SecurityProvider"),
		MaxLen (10),
		Deprecated {"CIM_Service.EnabledDefault"},
		Description (
			"StartMode is a string value indicating whether the "
			"Service is automatically started by a System, Operating "
			"System, etc. or only started upon request. This property "
			"is deprecated in lieu of AutomaticallyStarted, which "
			"addresses the same semantics. The change to a Boolean or "
			"uint16 data type was discussed when CIM V2.0 was defined."
			" However, existing V1.0 implementations used the string "
			"property and did not want to modify their code. "
			"Therefore, StartMode was grandfathered into the Schema. "
			"Use of the Deprecated qualifier allows the maintenance "
			"of the existing property, but also permits an improved, "
			"clarified definition using AutomaticallyStarted."),
		ValueMap {"Automatic", "Manual"} ]
	string StartMode;
	
	/* Service */
	[Override("Started"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Started is a boolean indicating whether the Service "
			"has been started (TRUE), or stopped (FALSE).") ]
	boolean Started;
	
	/* Service */
	[Override("StartService"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The StartService method places the Service in the started "
			"state. Note that this method's function overlaps with the "
			"RequestedStatus property. RequestedStatus was added to "
			"the model to maintain a record (i.e., a persisted value) "
			"of the last status request. Invoking the StartService "
			"method should set the RequestedStatus property appropriately."
			" The method returns an integer value of 0 if the Service was "
			"successfully started, 1 if the request is not supported and "
			"any other number to indicate an error. In a subclass, the "
			"set of possible return codes could be specified, using a "
			"ValueMap qualifier on the method. The strings to which the "
			"ValueMap contents are 'translated' may also be specified in "
			"the subclass as a Values array qualifier.") ]
	uint32 StartService();
	
	/* Service */
	[Override("StopService"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The StopService method places the Service in the stopped "
			"state. Note that this method's function overlaps with the "
			"RequestedStatus property. RequestedStatus was added to "
			"the model to maintain a record (i.e., a persisted value) "
			"of the last status request. Invoking the StopService "
			"method should set the RequestedStatus property appropriately."
			" The method returns an integer value of 0 if the Service was "
			"successfully stopped, 1 if the request is not supported and "
			"any other number to indicate an error. In a subclass, the "
			"set of possible return codes could be specified, using a "
			"ValueMap qualifier on the method. The strings to which the "
			"ValueMap contents are 'translated' may also be specified in "
			"the subclass as a Values array qualifier.") ]
	uint32 StopService();
	
	
	/* IBMTS_AccountManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method creates a IBMTS_Account and associates it with the CIMOM"),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 CreateAccount(
		[IN, Description ("UserID is the value used by the SecurityService to "
				"represent identity.") ]
		string UserID,
		[IN, Description("The user's password.") ]
		string Password,
		[IN, Description("The user's global security role"),
			Values {"Support", "Administrator", "Service", "Operator", "Backup", "Monitor", "None"}]
		string GlobalRole,
		[OUT, IN(false), Description("The created account") ]
		IBMTS_Account REF Account
	);

	/* IBMTS_AccountManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method add a system specific security role to an IBMTS_Account"),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 GrantGlobalAccess(
		[IN, Description ("The account.") ]
		IBMTS_Account REF Account,
		[IN, Description("The role"),
			Values {"Support", "Administrator", "Service", "Operator", "Backup", "Monitor", "None"}]
		string GlobalRole
	);

	/* IBMTS_AccountManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method add a system specific security role to an IBMTS_Account"),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("None") ]
	uint32 SetPassword(
		[IN, Description ("The account.") ]
		IBMTS_Account REF Account,
		[IN, Description("The password") ]
		string Password
	);

	/* IBMTS_AccountManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method add a system specific security role to an IBMTS_Account"),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 GrantSystemAccess(
		[IN, Description ("The account.") ]
		IBMTS_Account REF Account,
		[IN, Description("The system.") ]
		CIM_System REF System,
		[IN, Description("The role"),
			Values {"Support", "Administrator", "Service", "Operator", "Backup", "Monitor", "None"}]
		string Role
	);

	/* IBMTS_AccountManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description ("This method add a system specific security role to an IBMTS_Account"),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 DeleteAccount(
		[IN, Description ("The account.") ]
		IBMTS_Account REF Account
	);
};


// ===================================================================
//                           ASSOCIATIONS
// ===================================================================

// ===================================================================
// IBMTS_ManagesAccount
// ===================================================================
[Association, Provider("com.ibm.provider.security.SecurityProvider"),
	Description("Associates the AccountManagementService with the Accounts.")]
class IBMTS_ManagesAccount : CIM_ManagesAccount
{
	/* IBMTS_ManagesAccount */
	[Override("Antecedent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description ("The AccountManagementService.")]
	IBMTS_AccountManagementService REF Antecedent;
	
	/* IBMTS_ManagesAccount */
	[Override("Dependent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description ("The Account.") ]
	IBMTS_Account REF Dependent;
};

// ===================================================================
// IBMTS_AccountManagementServiceForSystem
// ===================================================================
[Association, Provider("com.ibm.provider.security.SecurityProvider"),
	Description("Associates the AccountManagementService with the CIMOM."), AccessRole("None") ]
class IBMTS_AccountManagementServiceForSystem : CIM_HostedService
{
	/* IBMTS_AccountManagementServiceForSystem */
	[Override("Antecedent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description ("The AccountManagementService."), ReadRole("None") ]
	IBMTS_AccountManagementService REF Antecedent;
	
	/* IBMTS_AccountManagementServiceForSystem */
	[Override("Dependent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description ("The CIM Object Manager."), ReadRole("None") ]
	IBMTS_ObjectManager REF Dependent;
};

// ===================================================================
// IBMTS_AccountOnCIMOM
// ===================================================================
[Association, Aggregation, Provider("com.ibm.provider.security.SecurityProvider"),
	Description("Associates the Accounts with the hosting CIMOM."), AccessRole("None") ]
class IBMTS_AccountOnCIMOM : CIM_AccountOnSystem
{
	/* IBMTS_AccountOnCIMOM */
	[Override("GroupComponent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Aggregate, Key, Description ("The aggregating CIMOM for the Account."), ReadRole("None") ]
	IBMTS_ObjectManager REF GroupComponent;
	
	/* IBMTS_AccountOnCIMOM */
	[Override("PartComponent"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description ("The Account."), ReadRole("None") ]
	IBMTS_Account REF PartComponent;


	/*IBMTS_AccountOnCIMOM */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description("The account's role on the CIMOM."), ReadRole("Administrator")]
	string Role;
};



// ===================================================================
// IBMTS_TruststoreManagementService
// ===================================================================
[Provider ("com.ibm.provider.security.SecurityProvider") ,
	Description(
	    "Offers methods to manage the truststore as well"
	    "the contained certificates.") ]
class IBMTS_TruststoreManagementService : CIM_CredentialManagementService
{
	/* ManagedElement */
	[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Caption property is a short textual description (one- "
			"line string) of the object."),
		MaxLen ( 64 )]
	string Caption;
	
	/* ManagedElement */
	[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Description property provides a textual description of "
			"the object.")]
	string Description;
	
	/* ManagedElement */
	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A user-friendly name for the object. This property allows "
			"each instance to define a user-friendly name IN ADDITION TO "
			"its key properties/identity data, and description "
			"information. \n"
			"Note that ManagedSystemElement's Name property is also "
			"defined as a user-friendly name. But, it is often "
			"subclassed to be a Key. It is not reasonable that the same "
			"property can convey both identity and a user friendly name, "
			"without inconsistencies. Where Name exists and is not a Key "
			"(such as for instances of LogicalDevice), the same "
			"information MAY be present in both the Name and ElementName "
			"properties.")]
	string ElementName;
	
	/* ManagedSystemElement */
	[Override("InstallDate"), Provider("com.ibm.provider.security.SecurityProvider"),
		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;
	
	/* ManagedSystemElement */
	[Override("Name"), Provider("com.ibm.provider.security.SecurityProvider"),
		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."),
		MaxLen ( 1024 )]
	string Name;
	
	/* ManagedSystemElement */
	[Override("OperationalStatus"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Indicates the current status(es) of the element. Various "
			"operational statuses are defined. Many of the enumeration's "
			"values are self- explanatory. However, a few are not and "
			"are described in more detail. \n"
			"\"Stressed\" indicates that the element is functioning, but "
			"needs attention. Examples of \"Stressed\" states are "
			"overload, overheated, etc. \n"
			"\"Predictive Failure\" indicates that an element is "
			"functioning nominally but predicting a failure in the near "
			"future. \n"
			"\"In Service\" describes an element being configured, "
			"maintained, cleaned, or otherwise administered. \n"
			"\"No Contact\" indicates that the monitoring system has "
			"knowledge of this element, but has never been able to "
			"establish communications with it. \n"
			"\"Lost Communication\" indicates that the ManagedSystem "
			"Element is known to exist and has been contacted "
			"successfully in the past, but is currently unreachable. \n"
			"\"Stopped\" and \"Aborted\" are similar, although the "
			"former implies a clean and orderly stop, while the latter "
			"implies an abrupt stop where the element's state and "
			"configuration may need to be updated. \n"
			"\"Dormant\" indicates that the element is inactive or "
			"quiesced. \n"
			"\"Supporting Entity in Error\" describes that this element "
			"may be \"OK\" but that another element, on which it is "
			"dependent, is in error. An example is a network service or "
			"endpoint that cannot function due to lower layer networking "
			"problems. \n"
			"\"Completed\" indicates the element has completed its "
			"operation. This value should be combined with either OK, "
			"Error, or Degraded so that a client can till if the "
			"complete operation passed (Completed with OK), and failure "
			"(Completed with Error). Completed with Degraded would imply "
			"the operation finished, but did not complete OK or report "
			"an error. \n"
			"\"Power Mode\" indicates the element has additional power "
			"model information contained in the Associated "
			"PowerManagementService association. \n"
			"OperationalStatus replaces the Status property on "
			"ManagedSystemElement to provide a consistent approach to "
			"enumerations, to address implementation needs for an array "
			"property, and to provide a migration path from today's "
			"environment to the future. This change was not made earlier "
			"since it required the DEPRECATED qualifier. Due to the "
			"widespread use of the existing Status property in "
			"management applications, it is strongly RECOMMENDED that "
			"providers/instrumentation provide BOTH the Status and "
			"OperationalStatus properties. Further, the first value of "
			"OperationalStatus SHOULD contain the primary status for the "
			"element. When instrumented, Status (since it is "
			"single-valued) SHOULD also provide the primary status of "
			"the element."),
		ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
			"10", "11", "12", "13", "14", "15", "16", "17", "18", "..",
			"0x8000.." },
		Values { "Unknown", "Other", "OK", "Degraded", "Stressed",
			"Predictive Failure", "Error", "Non-Recoverable Error",
			"Starting", "Stopping", "Stopped", "In Service",
			"No Contact", "Lost Communication", "Aborted", "Dormant",
			"Supporting Entity in Error", "Completed", "Power Mode",
			"DMTF Reserved", "Vendor Reserved" }, ArrayType ( "Indexed" ),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.StatusDescriptions" }]
	uint16 OperationalStatus[];
	
	/* ManagedSystemElement */
	[Override("StatusDescriptions"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Strings describing the various OperationalStatus array "
			"values. For example, if \"Stopping\" is the value assigned "
			"to OperationalStatus, then this property may contain an "
			"explanation as to why an object is being stopped. Note that "
			"entries in this array are correlated with those at the same "
			"array index in OperationalStatus."),
		ArrayType ( "Indexed" ),
		ModelCorrespondence {
			"CIM_ManagedSystemElement.OperationalStatus" }]
	string StatusDescriptions[];
	
	/* ManagedSystemElement */
	[Override("Status"), Provider("com.ibm.provider.security.SecurityProvider"),
		Deprecated { "CIM_ManagedSystemElement.OperationalStatus" },
		Description (
			"A string indicating the current status of the object. "
			"Various operational and non-operational statuses are "
			"defined. This property is deprecated in lieu of "
			"OperationalStatus, which includes the same semantics in its "
			"enumeration. This change is made for 3 reasons: 1) Status "
			"is more correctly defined as an array. This overcomes the "
			"limitation of describing status via a single value, when it "
			"is really a multi-valued property (for example, an element "
			"may be OK AND Stopped. 2) A MaxLen of 10 is too restrictive "
			"and leads to unclear enumerated values. And, 3) The change "
			"to a uint16 data type was discussed when CIM V2.0 was "
			"defined. However, existing V1.0 implementations used the "
			"string property and did not want to modify their code. "
			"Therefore, Status was grandfathered into the Schema. Use of "
			"the Deprecated qualifier allows the maintenance of the "
			"existing property, but also permits an improved definition "
			"using OperationalStatus."),
		ValueMap { "OK", "Error", "Degraded", "Unknown", "Pred Fail",
			"Starting", "Stopping", "Service", "Stressed", "NonRecover",
			"No Contact", "Lost Comm", "Stopped" }, MaxLen ( 10 )]
	string Status;
	
	/* ManagedSystemElement */
	[Override("HealthState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Experimental, Description (
			"Indicates the current health of the element. This attribute "
			"expresses the health of this element but not necessarily "
			"that of its subcomponents. The possible values are 0 to 30, "
			"where 5 means the element is entirely healthy and 30 means "
			"the element is completely non-functional. The following "
			"continuum is defined: \n"
			"\"Non-recoverable Error\" (30) - The element has completed "
			"failed and recovery is not possible. All functionality "
			"provided by this element has been lost. \n"
			"\"Critical Failure\" (25) - The element is non-functional "
			"and recovery MAY NOT be possible. \n"
			"\"Major Failure\" (20) - The element is failing. It is "
			"possible the some or all of the functionality of this "
			"component is degraded or not working. \n"
			"\"Minor Failure\" (15) - All functionality is available but "
			"some MAY be degraded. \n"
			"\"Degraded/Warning\" (10) - The element is in working order "
			"and all functionality is provided. However, the element is "
			"not working to the best of its abilities. For example, the "
			"element may not be operating at optimal performance or it "
			"may be reporting recoverable errors. \n"
			"\"OK\" (5) - The element is fully functional and is "
			"operating within normal operational parameters and without "
			"error. \n"
			"\"Unknown\" (0) - The implementation can not report on "
			"HealthState at this time. \n"
			"DMTF has reserved the unused portion of the continuum for "
			"additional HealthStates in the future."),
		ValueMap { "0","5","10","15","20","25","30",".." },
		Values { "Unknown","OK","Degraded/Warning",
			"Minor failure","Major failure",
			"Critical failure","Non-recoverable error","DMTF Reserved" }]
	uint16 HealthState;
	
	/* EnabledLogicalElement */
	[Override("EnabledState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"EnabledState is an integer enumeration that indicates the "
			"enabled/disabled states of an element. It can also indicate "
			"the transitions between these requested states. For "
			"example, shutting down (value = 4) and starting (value=10) "
			"are transient states between enabled and disabled. The "
			"following text briefly summarizes the various "
			"enabled/disabled states: \n"
			"Enabled (2) indicates that the element is/could be "
			"executing commands, will process any queued commands, and "
			"queues new requests. \n"
			"Disabled (3) indicates that the element will not execute "
			"commands and will drop any new requests. \n"
			"Shutting Down (4) indicates that the element is in the "
			"process of going to a Disabled state. \n"
			"Not Applicable (5) indicates the element doesn't support "
			"being enabled/disabled. \n"
			"Enabled but Offline (6) indicates that the element may be "
			"completing commands, and will drop any new requests. \n"
			"Test (7) indicates that the element is in a test state. \n"
			"Deferred (8) indicates that the element may be completing "
			"commands, but will queue any new requests. \n"
			"Quiesce (9) indicates that the element is enabled but in a "
			"restricted mode. The element's behavior is similar to the "
			"Enabled state, but it only processes a restricted set of "
			"commands. All other requests are queued. \n"
			"Starting (10) indicates that the element is in the process "
			"of going to an Enabled state. New requests are queued."),
		ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
			"10", "11..32767", "32768..65535" },
		Values { "Unknown", "Other", "Enabled", "Disabled",
			"Shutting Down", "Not Applicable", "Enabled but Offline",
			"In Test", "Deferred", "Quiesce", "Starting",
			"DMTF Reserved", "Vendor Reserved" },
		ModelCorrespondence {
			"CIM_EnabledLogicalElement.OtherEnabledState" }]
	uint16 EnabledState = 5;
	
	/* EnabledLogicalElement */
	[Override("OtherEnabledState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A string describing the element's enabled/disabled state "
			"when the EnabledState property is set to 1 (\"Other\"). "
			"This property MUST be set to NULL when EnabledState is any "
			"value other than 1."),
		ModelCorrespondence { "CIM_EnabledLogicalElement.EnabledState" }]
	string OtherEnabledState;
	
	/* EnabledLogicalElement */
	[Override("RequestedState"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"RequestedState is an integer enumeration indicating the "
			"last requested or desired state for the element. The actual "
			"state of the element is represented by EnabledState. This "
			"property is provided to compare the last requested and "
			"current enabled/disabled states. Note that when "
			"EnabledState is set to 5 (\"Not Applicable\"), then this "
			"property has no meaning. By default, the element's "
			"RequestedState is 5 (\"No Change\"). Refer to the "
			"EnabledState's property Description for explanations of the "
			"values in the RequestedState enumeration. \n"
			"\n"
			"It should be noted that there are two new values in "
			"RequestedState that build on the statuses of EnabledState. "
			"These are \"Reboot\" (10) and \"Reset\" (11). The former, "
			"Reboot, refers to doing a \"Shut Down\" and then moving to "
			"an \"Enabled\" state. The latter, Reset, indicates that the "
			"element is first \"Disabled\" and then \"Enabled\". The "
			"distinction between requesting \"Shut Down\" and "
			"\"Disabled\" should also be noted. The former, Shut Down, "
			"requests an orderly transition to the Disabled state, and "
			"MAY involve removing power, to completely erase any "
			"existing state. The latter, the Disabled state, requests an "
			"immediate disabling of the element, such that it will not "
			"execute or accept any commands or processing requests. \n"
			"\n"
			"This property is set as the result of a method invocation "
			"(such as Start or StopService on CIM_Service), or may be "
			"overridden and defined as WRITEable in a subclass. The "
			"method approach is considered superior to a WRITEable "
			"property, since it allows an explicit invocation of the "
			"operation and the return of a result code. \n"
			"\n"
			"It is possible that a particular instance of "
			"EnabledLogicalElement may not support RequestedStateChange. "
			"If this occurs, the value 12 (\"Not Applicable\") is used."),
		ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
			"12", "..", "32768..65535" },
		Values { "Enabled", "Disabled", "Shut Down", "No Change",
			"Offline", "Test", "Deferred", "Quiesce", "Reboot", "Reset",
			"Not Applicable", "DMTF Reserved", "Vendor Reserved" },
		ModelCorrespondence { "CIM_EnabledLogicalElement.EnabledState" }]
	uint16 RequestedState = 12;
	
	/* EnabledLogicalElement */
	[Override("EnabledDefault"), Provider("com.ibm.provider.security.SecurityProvider"),
		Write, Description (
			"An enumerated value indicating an administrator's "
			"default/startup configuration for an element's Enabled "
			"State. By default, the element is \"Enabled\" (value=2)."),
		ValueMap { "2", "3", "5", "6", "7", "8..32767", "32768..65535" },
		Values { "Enabled", "Disabled", "Not Applicable",
			"Enabled but Offline", "No Default", "DMTF Reserved",
			"Vendor Reserved" }]
	uint16 EnabledDefault = 2;
	
	/* EnabledLogicalElement */
	[Override("TimeOfLastStateChange"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The date/time when the element's EnabledState last changed. "
			"If the state of the element has not changed and this "
			"property is populated, then it MUST be set to a 0 interval "
			"value. If a state change was requested, but rejected or not "
			"yet processed, the property MUST NOT be updated.")]
	datetime TimeOfLastStateChange;
	
	/* EnabledLogicalElement */
	[Override("RequestStateChange"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Requests that the element's state be changed to the value "
			"specified in the RequestedState parameter. When the "
			"requested state change takes place, the element's "
			"EnabledState and RequestedState will be the same. Invoking "
			"the RequestStateChange method multiple times could result "
			"in earlier requests being overwritten/lost. \n"
			"If 0 is returned, then the task completed successfully and "
			"the use of ConcreteJob was not required. If 4096 (0x1000) "
			"is returned, then the task will take some time to complete, "
			"ConcreteJob will be created, and its reference returned in "
			"the output parameter Job. Any other return code indicates "
			"an error condition."),
		ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
			"4097", "4098", "4099", "4100..32767", "32768..65535" },
		Values { "Completed with No Error", "Not Supported",
			"Unknown/Unspecified Error",
			"Can NOT complete within Timeout Period", "Failed",
			"Invalid Parameter", "In Use", "DMTF Reserved",
			"Method Parameters Checked - Job Started",
			"Invalid State Transition",
			"Use of Timeout Parameter Not Supported", "Busy",
			"Method Reserved", "Vendor Specific" },
		ModelCorrespondence { "CIM_EnabledLogicalElement.RequestedState"
		}]
	uint32 RequestStateChange(
		[IN, Description (
				"The state requested for the element. This information "
				"will be placed into the instance's RequestedState "
				"property if the RequestStateChange method's return code "
				"is 0, 3, or 4096 (0x1000) - 'Completed with No Error', "
				"'Timeout', or 'Job Started' respectively. Refer to the "
				"description of the EnabledState and RequestedState "
				"properties for the detailed meanings of the "
				"RequestedState values."),
			ValueMap { "2", "3", "4", "6", "7", "8", "9", "10", "11",
				"..", "32768..65535" },
			Values { "Enabled", "Disabled", "Shut Down", "Offline",
				"Test", "Defer", "Quiesce", "Reboot", "Reset",
				"DMTF Reserved", "Vendor Reserved" },
			ModelCorrespondence {
				"CIM_EnabledLogicalElement.RequestedState" }]
		uint16 RequestedState,
		[IN ( false ), OUT, Description (
				"Reference to the job (may be null if task completed).")]
		CIM_ConcreteJob REF Job,
		[IN, Description (
				"A timeout period that specifies the maximum amount of "
				"time that the client expects the transition to the new "
				"state to take. The interval format MUST be used to "
				"specify the TimeoutPeriod. A value of 0 or a null "
				"parameter indicates that the client has no time "
				"requirements for the transition. \n"
				"If this property does not contain 0 or null and the "
				"implementation doesn't support this parameter. A return "
				"code of 'Use Of Timeout Parameter Not Supported' MUST be "
				"returned.")]
		datetime TimeoutPeriod);
	
	/* Service */
	[Override("SystemCreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Propagated ( "CIM_System.CreationClassName" ),
		Description (
			"The scoping System's CreationClassName."),
		MaxLen ( 256 )]
	string SystemCreationClassName;
	
	/* Service */
	[Override("SystemName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Propagated ( "CIM_System.Name" ), Description (
			"The scoping System's Name."),
		MaxLen ( 256 )]
	string SystemName;
	
	/* Service */
	[Override("CreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description (
			"CreationClassName indicates the name of the class or the "
			"subclass used in the creation of an instance. When used "
			"with the other key properties of this class, this property "
			"allows all instances of this class and its subclasses to be "
			"uniquely identified."),
		MaxLen ( 256 )]
	string CreationClassName;
	
	/* Service */
	[Override("PrimaryOwnerName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Write, Description (
			"The name of the primary owner for the service, if one is "
			"defined. The primary owner is the initial support contact "
			"for the Service."),
		MaxLen ( 64 ),
		MappingStrings { "MIF.DMTF|General Information|001.3" }]
	string PrimaryOwnerName;
	
	/* Service */
	[Override("PrimaryOwnerContact"), Provider("com.ibm.provider.security.SecurityProvider"),
		Write, Description (
			"A string that provides information on how the primary owner "
			"of the Service can be reached (e.g. phone number, email "
			"address, ...)."),
		MaxLen ( 256 ),
		MappingStrings { "MIF.DMTF|General Information|001.4" }]
	string PrimaryOwnerContact;
	
	/* Service */
	[Override("StartMode"), Provider("com.ibm.provider.security.SecurityProvider"),
		Deprecated { "CIM_Service.EnabledDefault" }, Description (
			"StartMode is a string value indicating whether the Service "
			"is automatically started by a System, Operating System, "
			"etc. or only started upon request. This property is "
			"deprecated in lieu of the EnabledDefault property inherited "
			"from EnabledLogicalElement, which addresses the same "
			"semantics. The change to a uint16 data type was discussed "
			"when CIM V2.0 was defined. However, existing V1.0 "
			"implementations used the string property and did not want "
			"to modify their code. Therefore, StartMode was "
			"grandfathered into the Schema. Use of the Deprecated "
			"qualifier allows the maintenance of the existing property, "
			"but also permits an improved, clarified definition using "
			"EnabledDefault."),
		ValueMap { "Automatic", "Manual" }, MaxLen ( 10 )]
	string StartMode;
	
	/* Service */
	[Override("Started"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Started is a boolean indicating whether the Service has "
			"been started (TRUE), or stopped (FALSE).")]
	boolean Started;
	
	/* IBMTS_TruststoreManagementService */
	[Override("Started"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"AutoGenerationEnabled is a boolean indicating whether the auto generation has "
			"been enabled (TRUE), or disabled (FALSE).")]
	boolean AutoGenerationEnabled;
	
	/* IBMTS_TruststoreManagementService */
	[Override("Started"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"DefaultValidity is an uint32 that gives the set default validity.")]
	uint32 DefaultValidity;	
	
	/* Service */
	[Override("StartService"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The StartService method places the Service in the started "
			"state. Note that this method's function overlaps with the "
			"RequestedState property. RequestedState was added to the "
			"model to maintain a record (i.e., a persisted value) of the "
			"last state request. Invoking the StartService method should "
			"set the RequestedState property appropriately. The method "
			"returns an integer value of 0 if the Service was "
			"successfully started, 1 if the request is not supported and "
			"any other number to indicate an error. In a subclass, the "
			"set of possible return codes could be specified, using a "
			"ValueMap qualifier on the method. The strings to which the "
			"ValueMap contents are 'translated' may also be specified in "
			"the subclass as a Values array qualifier. \n"
			"\n"
			"Note that this method overlaps in semantics with the "
			"RequestStateChange method inherited from "
			"EnabledLogicalElement. This method is maintained since it "
			"has been widely implemented, and its simple 'start' "
			"semantics are convenient to use.")]
	uint32 StartService();
	
	/* Service */
	[Override("StopService"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The StopService method places the Service in the stopped "
			"state. Note that this method's function overlaps with the "
			"RequestedState property. RequestedState was added to the "
			"model to maintain a record (i.e., a persisted value) of the "
			"last state request. Invoking the StopService method should "
			"set the RequestedState property appropriately. The method "
			"returns an integer value of 0 if the Service was "
			"successfully stopped, 1 if the request is not supported and "
			"any other number to indicate an error. In a subclass, the "
			"set of possible return codes could be specified, using a "
			"ValueMap qualifier on the method. The strings to which the "
			"ValueMap contents are 'translated' may also be specified in "
			"the subclass as a Values array qualifier. \n"
			"\n"
			"Note that this method overlaps in semantics with the "
			"RequestStateChange method inherited from "
			"EnabledLogicalElement. This method is maintained since it "
			"has been widely implemented, and its simple 'stop' "
			"semantics are convenient to use.")]
	uint32 StopService();
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method creates IBMTS_Certificates."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 GenerateCIMOMCertificate(
		[IN, Description("The instance of IBMTS_CertificateSetting that describes the settings.")]
		IBMTS_CertificateSetting REF CertificateSetting,
		[IN, Description("Forces the creation of a new server certificate even though the existing on is still valid.")]
		boolean Force,
		[OUT, IN(false), Description("The reference of the newly created"
		                             " instance of IBMTS_Certificate") ]
		IBMTS_Certificate REF Certificate
	);
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method deletes an IBMTS_Certificate from the truststore."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 DeleteCertificate(
		[IN, Description("The IBMTS_Certificate to be deleted.")]
		IBMTS_Certificate REF Certificate
	);
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method enables the auto generation of IBMTS_Certificates if they expire."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 EnableAutoGeneration();
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method disables the auto generation of IBMTS_Certificates if they expire."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 DisableAutoGeneration();
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"This method sets the default validity of auto-generated IBMTS_Certificates."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 SetDefaultValidity(
	    [IN, Description("The default validity for auto generation of certificates.")]
		uint32 DefaultValidity
	);
	
	/* IBMTS_TruststoreManagementService */
	[Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Checks the validity of a certificate."),
		ValueMap {"0", "1", "2", "5"},
		Values {"Success", "Not Supported", "Failed", "Wrong Parameter Set"},
		ExecuteRole("Administrator") ]
	uint32 CheckValidity(
	    [IN, Description("The reference to the instance of IBMTS_Certificate.")]
		IBMTS_Certificate REF Certificate,
		[OUT, IN(false), Description("The boolean validity of the IBMTS_Certificate") ]
		boolean IsValid,
		[OUT, IN(false), Description("The validity of the IBMTS_Certificate") ]
		uint32 Validity
	);
	
	
};

// ===================================================================
// IBMTS_Truststore
// ===================================================================
[Provider ("com.ibm.provider.security.SecurityProvider") ,
	Description(
	    "The truststore class represents a container that hosts"
	    "certificates. The CIM Agent uses exactly one truststore"
	    "which resides on CIM Agent (Server) side.") ]
class IBMTS_Truststore : CIM_SettingData
{
	/* ManagedElement */
	[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Caption property is a short textual description (one- "
			"line string) of the object."),
		MaxLen ( 64 )]
	string Caption;
	
	/* ManagedElement */
	[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Description property provides a textual description of "
			"the object.")]
	string Description;
	
	/* SettingData */
	[Override("InstanceID"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description (
			"Within the scope of the instantiating Namespace, InstanceID "
			"opaquely and uniquely identifies an instance of this class. "
			"In order to ensure uniqueness within the NameSpace, the "
			"value of InstanceID SHOULD be constructed using the "
			"following 'preferred' algorithm: \n"
			"<OrgID>:<LocalID> \n"
			"Where <OrgID> and <LocalID> are separated by a colon ':', "
			"and where <OrgID> MUST include a copyrighted, trademarked "
			"or otherwise unique name that is owned by the business "
			"entity creating/defining the InstanceID, or is a registered "
			"ID that is assigned to the business entity by a recognized "
			"global authority (This is similar to the <Schema "
			"Name>_<Class Name> structure of Schema class names.) In "
			"addition, to ensure uniqueness <OrgID> MUST NOT contain a "
			"colon (':'). When using this algorithm, the first colon to "
			"appear in InstanceID MUST appear between <OrgID> and "
			"<LocalID>. \n"
			"<LocalID> is chosen by the business entity and SHOULD not "
			"be re-used to identify different underlying (real-world) "
			"elements. If the above 'preferred' algorithm is not used, "
			"the defining entity MUST assure that the resultant "
			"InstanceID is not re-used across any InstanceIDs produced "
			"by this or other providers for this instance's NameSpace. \n"
			"For DMTF defined instances, the 'preferred' algorithm MUST "
			"be used with the <OrgID> set to 'CIM'.")]
	string InstanceID;
	
	/* SettingData */
	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Required, Description (
			"The user friendly name for this instance of SettingData. In "
			"addition, the user friendly name can be used as a index "
			"property for a search of query. (Note: Name does not have "
			"to be unique within a namespace.)")]
	string ElementName;
	
	
};

// ===================================================================
// IBMTS_Certificate
// ===================================================================
[Provider ("com.ibm.provider.security.SecurityProvider") ,
	Description("...") ]
class IBMTS_Certificate : CIM_PublicKeyCertificate
{
	/* ManagedElement */
	[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Caption property is a short textual description (one- "
			"line string) of the object."),
		MaxLen ( 64 )]
	string Caption;
	
	/* ManagedElement */
	[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The Description property provides a textual description of "
			"the object.")]
	string Description;
	
	/* ManagedElement */
	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"A user-friendly name for the object. This property allows "
			"each instance to define a user-friendly name IN ADDITION TO "
			"its key properties/identity data, and description "
			"information. \n"
			"Note that ManagedSystemElement's Name property is also "
			"defined as a user-friendly name. But, it is often "
			"subclassed to be a Key. It is not reasonable that the same "
			"property can convey both identity and a user friendly name, "
			"without inconsistencies. Where Name exists and is not a Key "
			"(such as for instances of LogicalDevice), the same "
			"information MAY be present in both the Name and ElementName "
			"properties.")]
	string ElementName;
	
	/* Credential */
	[Override("Issued"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The date and time when the credential was issued. Use a "
			"value of all 0s if this information is not applicable.")]
	datetime Issued;
	
	/* Credential */
	[Override("Expires"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The date and time when the credential expires (and is not "
			"appropriate for use for authentication/ authorization). Use "
			"a value of all 9s if this information is not applicable. "
			"Note that this property does not define how the expiration "
			"is set - but that there IS an expiration. The property may "
			"be set to either a specific date/time or an interval "
			"(calculated from the Issued datetime). For example, for "
			"Certificate Authority-signed public key, the expiration is "
			"determined by the CA. Another example is a voice mail "
			"password that expires 60 days after it is set/issued.")]
	datetime Expires;
	
	/* PublicKeyCertificate */
	[Override("SystemCreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key,
		Propagated ( "CIM_CertificateAuthority.SystemCreationClassName"
		), Description (
			"The scoping System's CCN."),
		MaxLen ( 256 )]
	string SystemCreationClassName;
	
	/* PublicKeyCertificate */
	[Override("SystemName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Propagated ( "CIM_CertificateAuthority.SystemName" ),
		Description (
			"The scoping System's Name."),
		MaxLen ( 256 )]
	string SystemName;
	
	/* PublicKeyCertificate */
	[Override("ServiceCreationClassName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Propagated ( "CIM_CertificateAuthority.CreationClassName" ),
		Description (
			"The scoping Service's CCN."),
		MaxLen ( 256 )]
	string ServiceCreationClassName;
	
	/* PublicKeyCertificate */
	[Override("ServiceName"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Propagated ( "CIM_CertificateAuthority.Name" ),
		Description (
			"The scoping Service's Name."),
		MaxLen ( 256 )]
	string ServiceName;
	
	/* PublicKeyCertificate */
	[Override("Subject"), Provider("com.ibm.provider.security.SecurityProvider"),
		Key, Description (
			"Certificate subject identifier."),
		MaxLen ( 256 )]
	string Subject;
	
	/* PublicKeyCertificate */
	[Override("AltSubject"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"Alternate subject identifier for the Certificate."),
		MaxLen ( 256 )]
	string AltSubject;
	
	/* PublicKeyCertificate */
	[Override("PublicKey"), Provider("com.ibm.provider.security.SecurityProvider"),
		Description (
			"The DER-encoded raw public key."),
		OctetString]
	uint8 PublicKey[];
	
	

/* IBMTS_Certificate */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Type of certificate.")]
string Type;

/* IBMTS_Certificate */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Algorithm of certificate.")]
string Algorithm;


/* IBMTS_Certificate */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Validity of certificate.")]
uint32 Validity;
	
	
};


// ===================================================================
// IBMTS_CertificateSetting
// ===================================================================
//[Provider ("com.ibm.provider.security.SecurityProvider") ,
//	Description("...") ]
//class IBMTS_CertificateSetting : CIM_ElementSettingData
//{
//	/* ElementSettingData */
//	[Override("ManagedElement"), Provider("com.ibm.provider.security.SecurityProvider"),
//		Key, Description (
//			"The managed element.")]
//	CIM_ManagedElement REF ManagedElement;
//	
//	/* ElementSettingData */
//	[Override("SettingData"), Provider("com.ibm.provider.security.SecurityProvider"),
//		Key, Description (
//			"The SettingData object associated with the element.")]
//	CIM_SettingData REF SettingData;
//	
//	/* ElementSettingData */
//	[Override("IsDefault"), Provider("com.ibm.provider.security.SecurityProvider"),
//		Description (
//			"An enumerated integer indicating that the referenced "
//			"setting is a default setting for the element, or that this "
//			"information is unknown."),
//		ValueMap { "0", "1", "2" },
//		Values { "Unknown", "Is Default", "Is Not Default" }]
//	uint16 IsDefault;
//	
//	/* ElementSettingData */
//	[Override("IsCurrent"), Provider("com.ibm.provider.security.SecurityProvider"),
//		Description (
//			"An enumerated integer indicating that the referenced "
//			"setting is currently being used in the operation of the "
//			"element, or that this information is unknown."),
//		ValueMap { "0", "1", "2" },
//		Values { "Unknown", "Is Current", "Is Not Current" }]
//	uint16 IsCurrent;
	
	
// ===================================================================
// IBMTS_CertificateSetting
// ===================================================================

[  Description ("Setting data for creation of new certificates."), AccessRole("None") ]
class IBMTS_CertificateSetting : CIM_SettingData
{

/* ManagedElement */
[Override("Caption"), Provider("com.ibm.provider.security.SecurityProvider"),
	MaxLen (64), Description ("Unsupported property."),
	MappingStrings {"null"} ]
string Caption;

/* ManagedElement */
[Override("Description"), Provider("com.ibm.provider.security.SecurityProvider"),
	Description (
		"The Description property provides a textual description of "
		"the object.") ]
string Description = "The vital product data of a node.";

//	//* ManagedElement */
//	[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
//	Description (
//        "  A user-friendly name for the object. This property allows "
//        "each instance to define a user-friendly name IN ADDITION TO its "
//        "key properties/identity data, and description information. \n"
//        "  Note that ManagedSystemElement's Name property is also defined "
//        "as a user-friendly name. But, it is often subclassed to be a "
//        "Key. It is not reasonable that the same property can convey "
//        "both identity and a user friendly name, without inconsistencies. "
//        "Where Name exists and is not a Key (such as for instances of "
//        "LogicalDevice), the same information MAY be present in both "
//        "the Name and ElementName properties.") ]
//    string ElementName;
// Override by SettingData

//	//* SettingData */
[Override("InstanceID"), Provider("com.ibm.provider.security.SecurityProvider"),
	Key, Description (
		"InstanceID opaquely identifies a unique instance of "
		"SettingData.  The InstanceID must be unique within a "
		"namespace. In order to ensure uniqueness, the value of "
		"InstanceID SHOULD be constructed in the following manner: \n"
		"(Vendor ID)(ID) \n")]
string InstanceID;

/* SettingData */
[Override("ElementName"), Provider("com.ibm.provider.security.SecurityProvider"),
	Required, Description ("Unsupported property."),
	MappingStrings {"null"} ]
string ElementName;

/* IBMTS_CertificateSetting */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("ServerCertificateName")]
string ServerCertificateName;

/* IBMTS_CertificateSetting */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("SignerCertificateName")]
string SignerCertificateName;

/* IBMTS_CertificateSetting */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Validity of certificate in days")]
uint32 Validity;

/* IBMTS_CertificateSetting */
[Provider("com.ibm.provider.security.SecurityProvider"),
	Description ("Auto generation of certificate as soon as the old one expires.")]
boolean AutoGenerationEnabled; 

};
