
#pragma namespace ("/root/lsissi")

#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 EmbeddedInstance : string,
    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);

//Introduce a new Qualifier here-------------------------------------------
Qualifier ProviderName : string = null, 
    Scope(class, association, indication), 
    Flavor(Restricted, Translatable);

// CIM_ManagedElement

    [Abstract(true),
     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. \nNote 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;

};

// CIM_IndicationFilter

    [Version("2.6.0"),
     Provider("internal:cim_indicationfilter"),
     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.")
    ]
class CIM_IndicationFilter : CIM_ManagedElement {
    [Key(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     Description("The language in which the query is expressed.")
    ]
    string QueryLanguage;

};

// CIM_ListenerDestination

    [Abstract(true),
     Version("2.8.0"),
     Provider("internal:cim_listenerdestination"),
     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(true),
     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(true),
     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(true),
     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(true),
     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_IndicationSubscription

    [Association(true),
     Version("2.7.0"),
     Provider("internal:cim_indicationsubscription"),
     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(true),
     Description("The Filter that defines the criteria and data of the possible Indications of this subscription.")
    ]
    CIM_IndicationFilter REF Filter;

     [Key(true),
     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(true),
     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(true),
     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;

};

// CIM_Synchronized

    [Association(true),
     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(true),
     Description("SystemElement represents one ManagedElement that is synchronized with the entity referenced as SyncedElement.")
    ]
    CIM_ManagedElement REF SystemElement;

     [Key(true),
     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;

};

// CIM_Dependency

    [Association(true),
     Abstract(true),
     Version("2.6.0"),
     Description("CIM_Dependency is a generic association used to establish dependency relationships between ManagedElements.")
    ]
class CIM_Dependency {
    [Key(true),
     Description("Antecedent represents the independent object in this association.")
    ]
    CIM_ManagedElement REF Antecedent;

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

};

// CIM_Component

    [Association(true),
     Abstract(true),
     Aggregation(true),
     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(true),
     Aggregate(true),
     Description("The parent element in the association.")
    ]
    CIM_ManagedElement REF GroupComponent;

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

};

// CIM_ManagedSystemElement

    [Abstract(true),
     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. \nOperationalStatus 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;

};

// CIM_LogicalElement

    [Abstract(true),
     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 {
};

// CIM_EnabledLogicalElement

    [Abstract(true),
     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: \nEnabled (2) indicates that the element is/could be executing commands, will process any queued commands, and queues new requests. \nDisabled (3) indicates that the element will not execute commands and will drop any new requests. \nShutting Down (4) indicates that the element is in the process of going to a Disabled state. \nNot Applicable (5) indicates the element doesn\'t support being enabled/disabled. \nEnabled but Offline (6) indicates that the element may be completing commands, and will drop any new requests. \nTest (7) indicates that the element is in a test state. \nDeferred (8) indicates that the element may be completing commands, but will queue any new requests. \nQuiesce (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. \nStarting (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\nIt 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\nThis 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(true),
     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. \nIf 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(true), 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(true), Description("Reference to the job (may be null if task completed).")] CIM_ConcreteJob REF Job, [IN(true), 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. \nIf 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);
};

// CIM_ServiceAccessPoint

    [Abstract(true),
     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 {
    [Key(true),
     Propagated("CIM_System.CreationClassName"),
     Description("The scoping System\'s CreationClassName."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

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

     [Key(true),
     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(true),
     Override("Name"),
     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."),
     MaxLen(256)
    ]
    string Name;

};

// CIM_SAPAvailableForElement

    [Association(true),
     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(true),
     Description("The Service Access Point that is available.")
    ]
    CIM_ServiceAccessPoint REF AvailableSAP;

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

};

// CIM_SettingData

    [Abstract(true),
     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. \nNote 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(true),
     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> \nWhere <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(true),
     Override("ElementName"),
     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;

};

// CIM_ElementSettingData

    [Association(true),
     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(true),
     Description("The managed element.")
    ]
    CIM_ManagedElement REF ManagedElement;

     [Key(true),
     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;

};

// CIM_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\nThe 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\nNote 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(true),
     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> \nWhere <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[];

};

// CIM_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\nNote that this class and its AuthorizedSubject/Target associations provide a short-hand, static mechanism to represent authorization policies.")
    ]
class CIM_AuthorizedPrivilege : CIM_Privilege {
};

// CIM_AuthorizedSubject

    [Association(true),
     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(true),
     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(true),
     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;

};

// LSISSI_StorageArrayPassword

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_StorageArrayPassword {
    [Key(true),
     MaxLen(64),
     Description("The instance ID of this object.  Comprised of LSISSI_StorageSystem.Name  + \'_Session Password\' .")
    ]
    string InstanceID;

     [Description("The saved Secret property from the SharedSecret.  Encrypted with Blowfish.")
    ]
    sint8 Secret[];

     [Description("The saved RemoteID property from the SharedSecret.")
    ]
    string RemoteID;

     [Description("The saved Algorithm property from the SharedSecret"),
     ValueMap{"0", "1"},
     Values{"HMAC-MD5", "PLAINTEXT"}
    ]
    uint8 Algorithm;

     [Description("The saved Protocol property from the SharedSecret.")
    ]
    string Protocol;

};

// CIM_AuthorizedTarget

    [Association(true),
     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(true),
     Description("The AuthorizedPrivilege affecting the target resource.")
    ]
    CIM_AuthorizedPrivilege REF Privilege;

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

};

// CIM_Job

    [Abstract(true),
     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{"CIM_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(true),
     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(true),
     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(true),
     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(true),
     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\nWhen 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(true),
     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(true),
     Description("The time interval after midnight when the Job should be processed. For example, \n00000000020000.000000:000 \nindicates 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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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;

     [Description("Describes the recovery action to be taken for an unsuccessfully run Job. The possible values are: \n0 = \"Unknown\", meaning it is unknown as to what recovery action to take \n1 = \"Other\", indicating that the recovery action will be specified in the property, OtherRecoveryAction \n2 = \"Do Not Continue\", meaning stop the execution of the job and appropriately update its status \n3 = \"Continue With Next Job\", meaning continue with the next job in the queue \n4 = \"Re-run Job\", indicating that the job should be re-run \n5 = \"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;

    [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. \nA 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(true), Description("Indicates whether or not the Job should be automatically deleted upon termination. This parameter takes precedence over the property, DeleteOnCompletion.")] boolean DeleteOnKill);
};

// CIM_OwningJobElement

    [Association(true),
     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(true),
     Max(1),
     Description("The ManagedElement responsible for the creation of the Job.")
    ]
    CIM_ManagedElement REF OwningElement;

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

};

// CIM_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. \nNote 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(true),
     Description("Commonly used Product name."),
     MaxLen(256),
     MappingStrings{"MIF.DMTF|ComponentID|001.2"},
     ModelCorrespondence{"PRS_Product.ProductName"}
    ]
    string Name;

     [Key(true),
     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(true),
     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(true),
     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;

};

// CIM_ProductParentChild

    [Association(true),
     Aggregation(true),
     Composition(true),
     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(true),
     Aggregate(true),
     Description("The parent Product in the association.")
    ]
    CIM_Product REF Parent;

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

};

// CIM_Indication

    [Indication(true),
     Abstract(true),
     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\nTo 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;

};

// LSISSI_ProviderConfig

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ProviderConfig {
    [Key(true),
     Description("Instance identifier which consists of the creation class name followed by an identifier that is unique to that class. ")
    ]
    string InstanceID;

     [Description("An IP address or host name from which an IP address can be resolved on the local subnet.  The name/address can be of a directly managed or host-agent managed (in-band) device. ")
    ]
    string HostNameOrIPAddr;

     [Description("An IP address for the alternate controller, if one exists, of the managed (in-band) device.  ")
    ]
    string AlternateIPAddr;

     [Description("Enumeration indicating the type of provider."),
     ValueMap{"0", "1"},
     Values{"Host", "Storage System"}
    ]
    uint16 Dedicated = 1;

     [Description("Enable/Disable AutomaticDiscovery")
    ]
    boolean AutomaticDiscoveryEnabled = true;

     [Description("The variable-length string that identifies information about the storage array administrator.  May be null.")
    ]
    string PrimaryOwnerName;

     [Description("The variable-length string that identifies information about the storage array administrator.  May be null.")
    ]
    string PrimaryOwnerContact;

     [Description("The Storage System WWN (known as the StorageArrayID) which can be used to uniquely identify a Storage Array.")
    ]
    string StorageArrayID;

};

// CIM_Location

    [Version("2.6.0"),
     Description("The Location class specifies the position and address of a PhysicalElement.")
    ]
class CIM_Location : CIM_ManagedElement {
    [Key(true),
     Description("Name is a free-form string defining a label for the Location. It is a part of the key for the object."),
     MaxLen(256)
    ]
    string Name;

     [Key(true),
     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."),
     MaxLen(256)
    ]
    string PhysicalPosition;

     [Description("Address is a free-form string indicating a street, building or other type of address for the PhysicalElement\'s Location."),
     MaxLen(1024)
    ]
    string Address;

};

// CIM_ElementLocation

    [Association(true),
     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(true),
     Description("The ManagedElement whose Location is specified.")
    ]
    CIM_ManagedElement REF Element;

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

};

// CIM_StatisticalData

    [Abstract(true),
     Version("2.7.1000"),
     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(true),
     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> \nWhere <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(true),
     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;

     [Experimental(true),
     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;

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

     [Experimental(true),
     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;

    [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. \nThe 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. \nIn 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(true)] string SelectedStatistics[]);
};

// CIM_ElementStatisticalData

    [Association(true),
     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(true),
     Min(1),
     Max(1),
     Description("The ManagedElement for which statistical or metric data is defined.")
    ]
    CIM_ManagedElement REF ManagedElement;

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

};

// CIM_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. \nA 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. \nThe 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(true),
     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> \nWhere <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. \nFor DMTF defined instances, the \'preferred\' algorithm MUST be used with the <OrgID> set to \'CIM\'.")
    ]
    string InstanceID;

     [Required(true),
     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", "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(true),
     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(true),
     Description("The version of this profile. The string representing the version MUST be in the form: \nM + \".\" + N + \".\" + U \nWhere: \nM - The major version (in numeric form) describing the profile\'s creation or last modification. \nN - The minor version (in numeric form) describing the profile\'s creation or last modification. \nU - The update (e.g. errata, patch, ..., in numeric form) describing the profile\'s creation or last modification.")
    ]
    string RegisteredVersion;

     [Required(true),
     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[];

};

// CIM_ElementConformsToProfile

    [Association(true),
     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(true),
     Description("The RegisteredProfile to which the ManagedElement conforms.")
    ]
    CIM_RegisteredProfile REF ConformantStandard;

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

};

// CIM_LogicalIdentity

    [Association(true),
     Abstract(true),
     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\nOne 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(true),
     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(true),
     Description("SameElement represents an alternate aspect of the ManagedElement.")
    ]
    CIM_ManagedElement REF SameElement;

};

// CIM_Collection

    [Abstract(true),
     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 {
};

// CIM_MemberOfCollection

    [Association(true),
     Aggregation(true),
     Version("2.6.0"),
     Description("CIM_MemberOfCollection is an aggregation used to establish membership of ManagedElements in a Collection.")
    ]
class CIM_MemberOfCollection {
    [Key(true),
     Aggregate(true),
     Description("The Collection that aggregates members.")
    ]
    CIM_Collection REF Collection;

     [Key(true),
     Description("The aggregated member of the Collection.")
    ]
    CIM_ManagedElement REF Member;

};

// CIM_AffectedJobElement

    [Association(true),
     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(true),
     Description("The ManagedElement affected by the execution of the Job.")
    ]
    CIM_ManagedElement REF AffectedElement;

     [Key(true),
     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[];

};

// CIM_Capabilities

    [Abstract(true),
     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(true),
     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> \nWhere <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(true),
     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;

};

// CIM_ElementCapabilities

    [Association(true),
     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(true),
     Min(1),
     Max(1),
     Description("The managed element.")
    ]
    CIM_ManagedElement REF ManagedElement;

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

};

// CIM_System

    [Abstract(true),
     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\nAlthough 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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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. \nNote 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[];

};

// 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. \nNote 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. \nNote 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(true),
     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> \nWhere <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_InstalledSoftwareIdentity

    [Association(true),
     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(true),
     Description("The system on which the software is installed.")
    ]
    CIM_System REF System;

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

};

// LSISSI_Provider

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_Provider {
    [Key(true),
     Required(true)
    ]
    string CreationClassName;

     [Key(true),
     Description("Displays build information")
    ]
    string BuildInfo;

};

// CIM_StorageSynchronized

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_ManagedElement REF SystemElement;

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

     [Description("CopyType describes the Replication Policy. Values are: \nAsync: create and maintain an asynchronous copy of the source. \nSync: create and maintain a synchronized copy of the source. \nUnSyncAssoc: 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: \nFull Copy: This indicates that a full copy of the source object is (or will be) generated . \nBefore Delta: This indicates that the source object will be maintained as a delta data from the replica. \nAfter Delta: This indicates that the replica will be maintained as delta data from the source object. \nLog: This indicates that the replica object is being maintained as a log of changes to the source. \nNot 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: \nInitialized: The link to enable replication is established. \nPrepareInProgress: Preparation for Replication is in progress. \nPrepared: All necessary preparation has completed. \nResyncInProgress: Synchronization or Resynchronization is in progress. \nThis may be the initial \'copy\' or subsequent changes being copied. \nSynchronized: An Async or Sync replication is currently synchronized. When this value is set, SyncMaintained will be true. \nFractureInProgress: An operation to fracture an Async or Sync replication is in progress. \nFractured: An Async or Sync replication is fractured. \nQuiesceInProgress: A quiesce operation is in progress. \nQuiesced: The replication has been quiesced and is ready for a change. \nRestoreInProgress: An operation is in progress to copy the Synced object to the System object. \nIdle: The \'normal\' state for an UnSyncAssoc replica. \nBroken: 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;

};

// CIM_ProviderCapabilities

    [Experimental(true),
     Version("2.7.1000"),
     Description("This class defines the capabilities of the associated provider.")
    ]
class CIM_ProviderCapabilities : CIM_Capabilities {
    [Required(true),
     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[];

};

// CIM_FiltersSupported

    [Association(true),
     Experimental(true),
     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."),
     Key(true)
    ]
    CIM_IndicationFilter REF Antecedent;

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

};

// CIM_LogicalDevice

    [Abstract(true),
     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(true),
     Propagated("CIM_System.CreationClassName"),
     Description("The scoping System\'s CreationClassName."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

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

     [Key(true),
     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(true),
     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. \nIf 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(true)
    ]
    uint64 PowerOnHours;

     [Description("The total number of hours that this Device has been powered."),
     Units("Hours"),
     Counter(true)
    ]
    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. \nMaximum 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(true), 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(true), 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. \nRequests 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. \nThe 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(true), 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. \nRequests 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. \nIf 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. \nOnlineDevice 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. \nNote 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(true), 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. \nRequests 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. \nThe 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(true), 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();
};

// CIM_ProtocolController

    [Abstract(true),
     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;

};

// CIM_ProtocolControllerForDevice

    [Association(true),
     Abstract(true),
     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."),
     Key(true)
    ]
    CIM_ProtocolController REF Antecedent;

     [Override("Dependent"),
     Description("The controlled Device."),
     Key(true)
    ]
    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;

};

// CIM_HostedDependency

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_ManagedElement REF Antecedent;

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

};

// CIM_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;

};

// CIM_BasedOn

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_StorageExtent REF Antecedent;

     [Override("Dependent"),
     Description("The higher level StorageExtent."),
     Key(true)
    ]
    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;

};

// CIM_Service

    [Abstract(true),
     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(true),
     Propagated("CIM_System.CreationClassName"),
     Description("The scoping System\'s CreationClassName."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

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

     [Key(true),
     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(true),
     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(true),
     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(true),
     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\nNote 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\nNote 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();
};

// CIM_ServiceAccessBySAP

    [Association(true),
     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."),
     Key(true)
    ]
    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."),
     Key(true)
    ]
    CIM_ServiceAccessPoint REF Dependent;

};

// CIM_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(true),
     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> \nWhere <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(true),
     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. \nConceptually 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(true),
     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(true), Description("The type of element for which supported sizes are reported for."), ValueMap{"2", "3"}, Values{"Storage Pool", "Storage Volume"}] uint16 ElementType, [IN(true), Description("The StorageSetting for which supported sizes should be reported for.")] CIM_StorageSetting REF Goal, [IN(false), OUT(true), Description("List of supported 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(true), Description("The type of element for which supported size ranges are reported for."), ValueMap{"2", "3"}, Values{"Storage Pool", "Storage Volume"}] uint16 ElementType, [IN(true), Description("The StorageSetting for which supported size ranges should be reported for.")] CIM_StorageSetting REF Goal, [IN(false), OUT(true), Description("The minimum size for a volume/pool in bytes."), Units("Bytes")] uint64 MinimumVolumeSize, [IN(false), OUT(true), Description("The maximum size for a volume/pool in bytes."), Units("Bytes")] uint64 MaximumVolumeSize, [IN(false), OUT(true), Description("A volume/pool size must be a multiple of this value which is specified in bytes."), Units("Bytes")] uint64 VolumeSizeDivisor);
};

// CIM_AllocatedFromStoragePool

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_StoragePool REF Antecedent;

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

     [Required(true),
     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;

};

// CIM_DeviceConnection

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_LogicalDevice REF Antecedent;

     [Override("Dependent"),
     Description("A second LogicalDevice connected to the Antecedent Device."),
     Key(true)
    ]
    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;

};

// CIM_ConcreteDependency

    [Association(true),
     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\nIt 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."),
     Key(true)
    ]
    CIM_ManagedElement REF Antecedent;

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

};

// CIM_PhysicalElement

    [Abstract(true),
     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(true),
     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(true),
     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"},
     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. \nNote 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;

     [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(true),
     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(true),
     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;

};

// CIM_Realizes

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_PhysicalElement REF Antecedent;

     [Override("Dependent"),
     Description("The LogicalDevice."),
     Key(true)
    ]
    CIM_LogicalDevice REF Dependent;

};

// CIM_ElementSoftwareIdentity

    [Association(true),
     Version("2.8.0"),
     Description("ElementSoftwareIdentity allows a Managed Element to report its software related asset information (firmware, drivers, configuration software, and etc.)")
    ]
class CIM_ElementSoftwareIdentity : CIM_Dependency {
    [Override("Antecedent"),
     Description("A LogicalElement\'s Software Asset."),
     Key(true)
    ]
    CIM_SoftwareIdentity REF Antecedent;

     [Override("Dependent"),
     Description("The ManagedElement that requires or uses the software."),
     Key(true)
    ]
    CIM_ManagedElement REF Dependent;

     [Description("Indicates the element\'s ability to upgrade this software asset. \n\'Resides off element\'(2), indicates the persistence of the software is outside of the element. Typically for a element this software is part of the OperatingSystem is typically upgradeable. \n\'Owner Upgradeable\' (3), indicates the persistence of the software is on the element and is upgradeable by the owner. \n\'FactoryUpgradeable\' (4),indicates the persistence of the software is on the element and is upgradeable by the manufacturer. \n\'Not Upgradeable\' (5), indicates the presistence of the software is on the element 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_ElementSoftwareIdentity.OtherUpgradeCondition"}
    ]
    uint16 UpgradeCondition;

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

};

// CIM_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. \nSeveral 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", "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(true)
    ]
    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(true),
     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(true), Description("If TRUE, lock the media. If FALSE release the media.")] boolean Lock);
};

// CIM_MediaPresent

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_MediaAccessDevice REF Antecedent;

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

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

};

// CIM_ReferencedProfile

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_RegisteredProfile REF Antecedent;

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

};

// CIM_SecurityService

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

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

// CIM_CredentialManagementService

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

// CIM_Credential

    [Abstract(true),
     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;

};

// CIM_ManagedCredential

    [Association(true),
     Version("2.8.0"),
     Description("This relationship associates a CredentialManagementService with the Credential it manages.")
    ]
class CIM_ManagedCredential : CIM_Dependency {
    [Override("Antecedent"),
     Max(1),
     Description("The credential management service."),
     Key(true)
    ]
    CIM_CredentialManagementService REF Antecedent;

     [Override("Dependent"),
     Description("The managed credential."),
     Key(true)
    ]
    CIM_Credential REF Dependent;

};

// CIM_SystemPackaging

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_PhysicalElement REF Antecedent;

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

};

// CIM_WBEMService

    [Abstract(true),
     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 {
};

// CIM_ProtocolAdapter

    [Version("2.7.0"),
     Description("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 {
    [Description("A human-readable name that uniquely identifies the Protocol Adapter within a system."),
     Key(true),
     Override("Name"),
     MaxLen(256)
    ]
    string Name;

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

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

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

};

// CIM_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(true),
     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(true),
     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 FunctionalProfilesSupported array."),
     ArrayType("Indexed"),
     ModelCorrespondence{"CIM_ObjectManagerCommunicationMechanism.FunctionalProfilesSupported"}
    ]
    string FunctionalProfileDescriptions[];

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

     [Required(true),
     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(true),
     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;

};

// CIM_CommMechanismForAdapter

    [Association(true),
     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."),
     Key(true)
    ]
    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."),
     Key(true)
    ]
    CIM_ObjectManagerCommunicationMechanism REF Dependent;

};

// CIM_ProviderModule

    [Experimental(true),
     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(true),
     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."),
     MaxLen(1024)
    ]
    string Name;

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

};

// CIM_Provider

    [Experimental(true),
     Version("2.7.1000"),
     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 {
    [Description("A human-readable name that uniquely identifies the provider within a system."),
     Key(true),
     Override("Name"),
     MaxLen(256)
    ]
    string Name;

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

};

// CIM_ProviderInModule

    [Association(true),
     Experimental(true),
     Version("2.7.1000"),
     Aggregation(true),
     Description("An association describing the Providers that are contained in a ProviderModule.")
    ]
class CIM_ProviderInModule : CIM_Component {
    [Override("GroupComponent"),
     Max(1),
     Description("The CIM ProviderModule."),
     Key(true),
     Aggregate(true)
    ]
    CIM_ProviderModule REF GroupComponent;

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

};

// CIM_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(true),
     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(true),
     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;

};

// CIM_RedundancyComponent

    [Association(true),
     Version("2.7.1"),
     Aggregation(true),
     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 {
    [Override("GroupComponent"),
     Description("The RedundancyComponent association indicates that \'this set of fans\' or \'these physical extents\' participate in a single RedundancyGroup."),
     Key(true),
     Aggregate(true)
    ]
    CIM_RedundancyGroup REF GroupComponent;

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

};

// CIM_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. \nA 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\nA 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(true), Description("The element to check for compatibility with this one.")] CIM_PhysicalElement REF ElementToCheck);
};

// CIM_Container

    [Association(true),
     Version("2.6.0"),
     Aggregation(true),
     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 {
    [Override("GroupComponent"),
     Max(1),
     Description("The PhysicalPackage that contains other PhysicalElements, including other Packages."),
     MappingStrings{"MIB.IETF|Entity-MIB.entPhysicalContainedIn"},
     Key(true),
     Aggregate(true)
    ]
    CIM_PhysicalPackage REF GroupComponent;

     [Override("PartComponent"),
     Description("The PhysicalElement which is contained in the Package."),
     Key(true)
    ]
    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_SystemComponent

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

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

};

// CIM_ProductPhysicalComponent

    [Association(true),
     Composition(true),
     Version("2.7.0"),
     Aggregation(true),
     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."),
     Key(true),
     Aggregate(true)
    ]
    CIM_Product REF GroupComponent;

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

};

// CIM_ConcreteComponent

    [Association(true),
     Version("2.7.0"),
     Aggregation(true),
     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\nIt 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 {
    [Override("GroupComponent"),
     Description("The parent element in the association."),
     Key(true),
     Aggregate(true)
    ]
    CIM_ManagedElement REF GroupComponent;

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

};

// LSISSI_ElementSettingData

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("ElementSettingData represents the association between ManagedElements and applicable setting data. This association also describes whether this is a default or current setting."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ElementSettingData : CIM_ElementSettingData {
};

// LSISSI_AuthorizedSubject

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_AuthorizedSubject : CIM_AuthorizedSubject {
};

// LSISSI_AuthorizedTarget

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("CIM_AuthorizedTarget is an association used to tie an Identity\'s or Role\'s AuthorizedPrivileges to specific target resources."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_AuthorizedTarget : CIM_AuthorizedTarget {
};

// LSISSI_OwningJobElement

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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"},
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_OwningJobElement : CIM_OwningJobElement {
};

// LSISSI_ProductParentChild

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Aggregation(true),
     Composition(true),
     Description("The CIM_ProductParentChild association defines a parent child hierarchy among Products. For example, a Product may come bundled with other Products."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ProductParentChild : CIM_ProductParentChild {
};

// CIM_InstIndication

    [Indication(true),
     Abstract(true),
     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(true),
     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(true)
    ]
    string SourceInstance;

};

// CIM_ProcessIndication

    [Indication(true),
     Abstract(true),
     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 {
};

// CIM_PhysicalElementLocation

    [Association(true),
     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."),
     Key(true)
    ]
    CIM_PhysicalElement REF Element;

     [Override("PhysicalLocation"),
     Max(1),
     Description("The PhysicalElement\'s Location."),
     Key(true)
    ]
    CIM_Location REF PhysicalLocation;

};

// LSISSI_ElementStatisticalData

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ElementStatisticalData : CIM_ElementStatisticalData {
};

// CIM_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(true),
     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;

     [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. \nNote: 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."),
     Key(true),
     Override("Name"),
     MaxLen(256)
    ]
    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;

};

// CIM_ObjectManagerIsProvider

    [Association(true),
     Experimental(true),
     Version("2.7.1000"),
     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."),
     Key(true)
    ]
    CIM_ObjectManager REF SystemElement;

     [Override("SameElement"),
     Description("SameElement represents an alternate aspect of the System entity."),
     Key(true)
    ]
    CIM_Provider REF SameElement;

};

// CIM_ConcreteIdentity

    [Association(true),
     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\nIt 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."),
     Key(true)
    ]
    CIM_ManagedElement REF SystemElement;

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

};

// LSISSI_MemberOfCollection

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Aggregation(true),
     Description("CIM_MemberOfCollection is an aggregation used to establish membership of ManagedElements in a Collection."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_MemberOfCollection : CIM_MemberOfCollection {
};

// LSISSI_AffectedJobElement

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_AffectedJobElement : CIM_AffectedJobElement {
};

// CIM_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\nWithin 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\nSubclasses 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(true),
     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> \nWhere <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("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;

};

// CIM_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(true),
     Propagated("CIM_ObjectManager.SystemCreationClassName"),
     Description("The scoping System\'s CreationClassName."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

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

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

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

     [Key(true),
     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(true),
     Description("A string to uniquely identify the Namespace within the ObjectManager."),
     MaxLen(256)
    ]
    string Name;

     [Deprecated{"CIM_Namespace.ClassType"},
     Required(true),
     Write(true),
     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(true),
     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(true),
     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(true),
     Description("The version of the objects in this namespace. The string representing the version MUST be in the form: \nM + \".\" + N + \".\" + U \nWhere: \nM - The major version (in numeric form) \nN - The minor version (in numeric form) \nU - The update (e.g. errata, patch, ..., in numeric form)"),
     ModelCorrespondence{"CIM_Namespace.DescriptionOfClassType", "CIM_Namespace.ClassType"}
    ]
    string ClassTypeVersion;

     [Write(true),
     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;

};

// CIM_ProviderElementCapabilities

    [Association(true),
     Experimental(true),
     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."),
     Key(true)
    ]
    CIM_Provider REF ManagedElement;

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

};

// LSISSI_ElementCapabilities

    [Association(true),
     Aggregation(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ElementCapabilities : CIM_ElementCapabilities {
};

// LSISSI_InstalledSoftwareIdentity

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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)."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_InstalledSoftwareIdentity : CIM_InstalledSoftwareIdentity {
};

// LSISSI_StorageSynchronized

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageSynchronized : CIM_StorageSynchronized {
    [Override("CopyType"),
     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{"4"},
     Values{"UnSyncAssoc"}
    ]
    uint16 CopyType;

};

// CIM_ProtocolControllerForUnit

    [Association(true),
     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 {
    [Description("The ProtocolController."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_ProtocolController REF Antecedent;

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

};

// CIM_ProtocolControllerAccessesUnit

    [Association(true),
     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 {
    [Description("The protocol controller."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_ProtocolController REF Antecedent;

     [Description("The logical unit (eg StorageVolume)."),
     Override("Dependent"),
     Key(true)
    ]
    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;

};

// CIM_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(true),
     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;

};

// CIM_ProtocolControllerForPort

    [Association(true),
     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 {
    [Description("The ProtocolController."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_ProtocolController REF Antecedent;

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

};

// CIM_HostedAccessPoint

    [Association(true),
     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 {
    [Min(1),
     Max(1),
     Description("The hosting System."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_System REF Antecedent;

     [Weak(true),
     Description("The SAP(s) that are hosted on this System."),
     Override("Dependent"),
     Key(true)
    ]
    CIM_ServiceAccessPoint REF Dependent;

};

// CIM_NamespaceInManager

    [Association(true),
     Version("2.7.0"),
     Description("NamespaceInManager is an association describing the Namespaces hosted by a CIM ObjectManager.")
    ]
class CIM_NamespaceInManager : CIM_HostedDependency {
    [Min(1),
     Max(1),
     Description("The ObjectManager containing a Namespace."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_ObjectManager REF Antecedent;

     [Weak(true),
     Description("The Namespace in an ObjectManager."),
     Override("Dependent"),
     Key(true)
    ]
    CIM_Namespace REF Dependent;

};

// LSISSI_HostedDependency

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("HostedDependency defines a ManagedElement in the context of another ManagedElement in which it resides.")
    ]
class LSISSI_HostedDependency : CIM_HostedDependency {
};

// CIM_HostedService

    [Association(true),
     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 {
    [Min(1),
     Max(1),
     Description("The hosting System."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_System REF Antecedent;

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

};

// CIM_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. \nAn 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(true),
     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> \nWhere <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;

};

// CIM_HostedCollection

    [Association(true),
     Version("2.7.0"),
     Description("HostedCollection defines a SystemSpecificCollection in the context of a scoping 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.")
    ]
class CIM_HostedCollection : CIM_HostedDependency {
    [Min(1),
     Max(1),
     Description("The scoping system."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_System REF Antecedent;

     [Description("The collection defined in the context of a system."),
     Override("Dependent"),
     Key(true)
    ]
    CIM_SystemSpecificCollection REF Dependent;

};

// LSISSI_BasedOn

    [Association(true),
     Aggregation(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_BasedOn : CIM_BasedOn {
};

// CIM_CommMechanismForManager

    [Association(true),
     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 {
    [Min(1),
     Max(1),
     Description("The specific ObjectManager whose communication mechanism is described."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_ObjectManager REF Antecedent;

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

};

// LSISSI_AllocatedFromStoragePool

    [Association(true),
     Aggregation(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("AllocatedFromStoragePool is an association describing how LogicalElements are allocated from underlying StoragePools. These elements typically would be subclasses of StorageExtents or StoragePools.")
    ]
class LSISSI_AllocatedFromStoragePool : CIM_AllocatedFromStoragePool {
};

// CIM_Controller

    [Abstract(true),
     Version("2.7.1000"),
     Description("Controller is a superclass for grouping the miscellaneous control-related Devices that provide a \'classic\' bus master interface. Examples of Controllers are USBControllers, SerialControllers, etc. The Controller class is an abstraction for Devices with a single protocol stack, which exist to control communications (data, control, and reset) to \'downstream\' devices. Note that a new abstract class (ProtocolController) has been created to model more complex interface controllers such as SCSI.")
    ]
class CIM_Controller : CIM_LogicalDevice {
    [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", "48"},
     Values{"Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI", "Flexible Diskette", "1496", "SCSI Parallel Interface", "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", "I2C", "Power", "HIPPI", "MultiBus", "VME", "IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5", "IEEE 802.3 10BASE2", "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", "DSSI", "QIC2", "Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)", "FIR (fast infrared)", "SIR (serial infrared)", "IrBus", "Serial ATA"},
     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;

};

// CIM_ControlledBy

    [Association(true),
     Version("2.7.1000"),
     Description("The ControlledBy relationship indicates which Devices are controlled by a CIM_Controller.")
    ]
class CIM_ControlledBy : CIM_DeviceConnection {
    [Description("The Controller."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_Controller REF Antecedent;

     [Description("The controlled Device."),
     Override("Dependent"),
     Key(true)
    ]
    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(true)
    ]
    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(true)
    ]
    uint32 NumberOfSoftResets;

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

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

     [Experimental(true),
     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;

};

// LSISSI_ConcreteDependency

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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\nIt 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 LSISSI_ConcreteDependency : CIM_ConcreteDependency {
};

// 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 {
    [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_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\nA 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\nA 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_RealizesExtent

    [Association(true),
     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 {
    [Max(1),
     Description("The PhysicalComponent on which the Extent is realized."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_PhysicalComponent REF Antecedent;

     [Description("The StorageExtent that is located on the Component."),
     Override("Dependent"),
     Key(true)
    ]
    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;

};

// LSISSI_Realizes

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("CIM_Realizes is the association that defines the mapping between LogicalDevices and the PhysicalElements that implement them.")
    ]
class LSISSI_Realizes : CIM_Realizes {
};

// LSISSI_ElementSoftwareIdentity

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("ElementSoftwareIdentity allows a Managed Element to report its software related asset information (firmware, drivers, configuration software, and etc.)")
    ]
class LSISSI_ElementSoftwareIdentity : CIM_ElementSoftwareIdentity {
};

// LSISSI_MediaPresent

    [Association(true),
     Aggregation(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_MediaPresent : CIM_MediaPresent {
};

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

// CIM_SubProfileRequiresProfile

    [Association(true),
     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 {
    [Min(1),
     Description("The RegisteredProfile that is referenced/required by the subprofile."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_RegisteredProfile REF Antecedent;

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

};

// CIM_LocalCredentialManagementService

    [Version("2.6.0"),
     Description("CIM_LocalCredentialManagementService is a credential management service that provides management of credentials used by the local system.")
    ]
class CIM_LocalCredentialManagementService : CIM_CredentialManagementService {
};

// CIM_SharedSecretService

    [Version("2.6.0"),
     Description("CIM_SharedSecretService is a service which ascertains whether messages received are from the Principal with whom a secret is shared. Examples include a login service that proves identity on the basis of knowledge of the shared secret, or a transport integrity service (like Kerberos provides) that includes a message authenticity code that proves each message in the messsage stream came from someone who knows the shared secret session key.")
    ]
class CIM_SharedSecretService : CIM_LocalCredentialManagementService {
    [Description("The Algorithm used to convey the shared secret, such as HMAC-MD5,or PLAINTEXT."),
     MaxLen(256)
    ]
    string Algorithm;

     [Description("The Protocol supported by the SharedSecretService.")
    ]
    string Protocol;

};

// CIM_SharedSecret

    [Version("2.8.0"),
     Description("CIM_SharedSecret is a secret (such as a password or the response to a challenge question) that is shared between a principal and a particular SharedSecret security service. Secrets may be in the form of a password used for initial authentication, or as with a session key, used as part of a message to verify the originator of the message. It is important to note that SharedSecret is not just a password, but rather is the password used with a particular security service.")
    ]
class CIM_SharedSecret : CIM_Credential {
    [Key(true),
     Propagated("CIM_SharedSecretService.SystemCreationClassName"),
     Description("The scoping System\'s CCN."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

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

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

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

     [Key(true),
     Description("RemoteID is the name by which the principal is known at the remote secret key authentication service."),
     MaxLen(256)
    ]
    string RemoteID;

     [Description("The secret known by the principal.")
    ]
    string Secret;

     [Description("The transformation algorithm, if any, used to protect passwords before use in the protocol. For instance, Kerberos doesn\'t store passwords as the shared secret, but rather, a hash of the password.")
    ]
    string Algorithm;

     [Description("The protocol with which the SharedSecret is used.")
    ]
    string Protocol;

};

// CIM_SharedSecretIsShared

    [Association(true),
     Version("2.6.0"),
     Description("This relationship associates a SharedSecretService with the SecretKey it verifies.")
    ]
class CIM_SharedSecretIsShared : CIM_ManagedCredential {
    [Min(1),
     Max(1),
     Description("The credential management service."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_SharedSecretService REF Antecedent;

     [Weak(true),
     Description("The managed credential."),
     Override("Dependent"),
     Key(true)
    ]
    CIM_SharedSecret REF Dependent;

};

// CIM_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"},
     MaxLen(64)
    ]
    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). \nA 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(true), 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(true), 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);
};

// CIM_ComputerSystemPackage

    [Association(true),
     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 {
    [Description("The PhysicalPackage(s) that realize a Unitary ComputerSystem."),
     Override("Antecedent"),
     Key(true)
    ]
    CIM_PhysicalPackage REF Antecedent;

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

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

};

// CIM_PackagedComponent

    [Association(true),
     Version("2.6.0"),
     Aggregation(true),
     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 {
    [Max(1),
     Description("The PhysicalPackage that contains Component(s)."),
     Override("GroupComponent"),
     MappingStrings{"MIB.IETF|Entity-MIB.entPhysicalContainedIn"},
     Key(true),
     Aggregate(true)
    ]
    CIM_PhysicalPackage REF GroupComponent;

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

};

// CIM_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;

};

// CIM_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. \nAn 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", "Notebook", "Hand Held", "Docking Station", "All in One", "Sub Notebook", "Space-Saving", "Lunch Box", "Main System Chassis", "Expansion Chassis", "SubChassis", "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. \nAn 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", "Notebook", "Hand Held", "Docking Station", "All in One", "Sub Notebook", "Space-Saving", "Lunch Box", "Main System Chassis", "Expansion Chassis", "SubChassis", "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;

};

// CIM_PackageInChassis

    [Association(true),
     Version("2.6.0"),
     Aggregation(true),
     Description("A Chassis can contain other Packages, such as other Chassis and Cards. The PackageInChassis association makes explicit this relationship.")
    ]
class CIM_PackageInChassis : CIM_Container {
    [Max(1),
     Description("The Chassis that contains other PhysicalPackages."),
     Override("GroupComponent"),
     MappingStrings{"MIB.IETF|Entity-MIB.entPhysicalContainedIn"},
     Key(true),
     Aggregate(true)
    ]
    CIM_Chassis REF GroupComponent;

     [Description("The PhysicalPackage which is contained in the Chassis."),
     Override("PartComponent"),
     Key(true)
    ]
    CIM_PhysicalPackage REF PartComponent;

};

// CIM_ComponentCS

    [Association(true),
     Composition(true),
     Version("2.7.0"),
     Aggregation(true),
     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\nWhen 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 {
    [Description("The ComputerSystem that contains and/or aggregates other Systems."),
     Override("GroupComponent"),
     Key(true),
     Aggregate(true)
    ]
    CIM_ComputerSystem REF GroupComponent;

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

};

// CIM_SystemDevice

    [Association(true),
     Composition(true),
     Version("2.7.0"),
     Aggregation(true),
     Description("LogicalDevices may be aggregated by a System. This relationship is made explicit by the SystemDevice association.")
    ]
class CIM_SystemDevice : CIM_SystemComponent {
    [Min(1),
     Max(1),
     Description("The parent system in the Association."),
     Override("GroupComponent"),
     Key(true),
     Aggregate(true)
    ]
    CIM_System REF GroupComponent;

     [Weak(true),
     Description("The LogicalDevice that is a component of a System."),
     Override("PartComponent"),
     Key(true)
    ]
    CIM_LogicalDevice REF PartComponent;

};

// CIM_HostedStoragePool

    [Association(true),
     Composition(true),
     Version("2.7.0"),
     Aggregation(true),
     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 {
    [Min(1),
     Max(1),
     Description("The parent system in the Association."),
     Override("GroupComponent"),
     Key(true),
     Aggregate(true)
    ]
    CIM_System REF GroupComponent;

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

};

// LSISSI_ProductPhysicalComponent

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Composition(true),
     Aggregation(true),
     Description("Indicates that the referenced PhysicalElement is acquired as part of a Product.")
    ]
class LSISSI_ProductPhysicalComponent : CIM_ProductPhysicalComponent {
};

// LSISSI_ConcreteComponent

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Aggregation(true),
     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\nIt 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 LSISSI_ConcreteComponent : CIM_ConcreteComponent {
};

// CIM_InstDeletion

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

// CIM_InstModification

    [Indication(true),
     Version("2.6.0"),
     Description("CIM_InstModification notifies when an instance is modified.")
    ]
class CIM_InstModification : CIM_InstIndication {
    [Required(true),
     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(true)
    ]
    string PreviousInstance;

};

// CIM_InstCreation

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

// CIM_AlertIndication

    [Indication(true),
     Version("2.8.0"),
     Description("A concrete superclass for CIM Alert notifications. An AlertIndication is a specialized type of CIM_Indication that contains information about the severity, cause, recommended actions and other data of a real world event. This event and its data may or may not be modeled in the CIM class hierarchy.")
    ]
class CIM_AlertIndication : CIM_ProcessIndication {
    [Description("A short description of the Indication."),
     MappingStrings{"Recommendation.ITU|X733.Additional text"}
    ]
    string Description;

     [Description("The identifying information of the entity (ie, the instance) for which this Indication is generated. The property contains the path of an instance, encoded as a string parameter - if the instance is modeled in the CIM Schema. If not a CIM instance, the property contains some identifying string that names the entity for which the Alert is generated. The path or identifying string is formatted per the AlertingElementFormat property."),
     ModelCorrespondence{"CIM_AlertIndication.AlertingElementFormat"}
    ]
    string AlertingManagedElement;

     [Description("The format of the AlertingManagedElement property is interpretable based upon the value of this property. Values are defined as: \n0 - Unknown. The format is unknown or not meaningfully interpretable by a CIM client application. \n1 - Other. The format is defined by the value of the OtherAlertingElementFormat property. \n2 - CIMObjectPath. The format is a CIMObjectPath, with format <NamespacePath>:<ClassName>.<Prop1>=\"<Value1>\", <Prop2>=\"<Value2>\", . . . specifying an instance in the CIM Schema."),
     ValueMap{"0", "1", "2"},
     Values{"Unknown", "Other", "CIMObjectPath"},
     ModelCorrespondence{"CIM_AlertIndication.AlertingManagedElement", "CIM_AlertIndication.OtherAlertingElementFormat"}
    ]
    uint16 AlertingElementFormat = 0;

     [Description("A string defining \"Other\" values for AlertingElementFormat. This value MUST be set to a non NULL value when AlertingElementFormat is set to a value of 1 (\"Other\"). For all other values of AlertingElementFormat, the value of this string must be set to NULL."),
     ModelCorrespondence{"CIM_AlertIndication.AlertingElementFormat"}
    ]
    string OtherAlertingElementFormat;

     [Required(true),
     Description("Primary classification of the Indication. The following values are defined: \n1 - Other. The Indication\'s OtherAlertType property conveys its classification. Use of \"Other\" in an enumeration is a standard CIM convention. It means that the current Indication does not fit into the categories described by this enumeration. \n2 - Communications Alert. An Indication of this type is principally associated with the procedures and/or processes required to convey information from one point to another. \n3 - Quality of Service Alert. An Indication of this type is principally associated with a degradation or errors in the performance or function of an entity. \n4 - Processing Error. An Indication of this type is principally associated with a software or processing fault. \n5 - Device Alert. An Indication of this type is principally associated with an equipment or hardware fault. \n6 - Environmental Alert. An Indication of this type is principally associated with a condition relating to an enclosure in which the hardware resides, or other environmental considerations. \n7 - Model Change. The Indication addresses changes in the Information Model. For example, it may embed a Lifecycle Indication to convey the specific model change being alerted. \n8 - Security Alert. An Indication of this type is associated with security violations, detection of viruses, and similar issues."),
     ValueMap{"1", "2", "3", "4", "5", "6", "7", "8"},
     Values{"Other", "Communications Alert", "Quality of Service Alert", "Processing Error", "Device Alert", "Environmental Alert", "Model Change", "Security Alert"},
     MappingStrings{"Recommendation.ITU|X733.Event type"}
    ]
    uint16 AlertType;

     [Description("A string describing the Alert type - used when the AlertType property is set to 1, \"Other State Change\"."),
     ModelCorrespondence{"CIM_AlertIndication.AlertType"}
    ]
    string OtherAlertType;

     [Required(true),
     Description("An enumerated value that describes the severity of the Alert Indication from the notifier\'s point of view: \n1 - Other, by CIM convention, is used to indicate that the Severity\'s value can be found in the OtherSeverity property. \n3 - Degraded/Warning should be used when its appropriate to let the user decide if action is needed. \n4 - Minor should be used to indicate action is needed, but the situation is not serious at this time. \n5 - Major should be used to indicate action is needed NOW. \n6 - Critical should be used to indicate action is needed NOW and the scope is broad (perhaps an imminent outage to a critical resource will result). \n7 - Fatal/NonRecoverable should be used to indicate an error occurred, but it\'s too late to take remedial action. \n2 and 0 - Information and Unknown (respectively) follow common usage. Literally, the AlertIndication is purely informational or its severity is simply unknown."),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7"},
     Values{"Unknown", "Other", "Information", "Degraded/Warning", "Minor", "Major", "Critical", "Fatal/NonRecoverable"},
     MappingStrings{"Recommendation.ITU|X733.Perceived severity"}
    ]
    uint16 PerceivedSeverity;

     [Description("Holds the value of the user defined severity value when \'Severity\' is 1 (\"Other\")."),
     ModelCorrespondence{"CIM_AlertIndication.PerceivedSeverity"}
    ]
    string OtherSeverity;

     [Required(true),
     Description("An enumerated value that describes the probable cause of the situation which resulted in the AlertIndication."),
     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", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130"},
     Values{"Unknown", "Other", "Adapter/Card Error", "Application Subsystem Failure", "Bandwidth Reduced", "Connection Establishment Error", "Communications Protocol Error", "Communications Subsystem Failure", "Configuration/Customization Error", "Congestion", "Corrupt Data", "CPU Cycles Limit Exceeded", "Dataset/Modem Error", "Degraded Signal", "DTE-DCE Interface Error", "Enclosure Door Open", "Equipment Malfunction", "Excessive Vibration", "File Format Error", "Fire Detected", "Flood Detected", "Framing Error", "HVAC Problem", "Humidity Unacceptable", "I/O Device Error", "Input Device Error", "LAN Error", "Non-Toxic Leak Detected", "Local Node Transmission Error", "Loss of Frame", "Loss of Signal", "Material Supply Exhausted", "Multiplexer Problem", "Out of Memory", "Output Device Error", "Performance Degraded", "Power Problem", "Pressure Unacceptable", "Processor Problem (Internal Machine Error)", "Pump Failure", "Queue Size Exceeded", "Receive Failure", "Receiver Failure", "Remote Node Transmission Error", "Resource at or Nearing Capacity", "Response Time Excessive", "Retransmission Rate Excessive", "Software Error", "Software Program Abnormally Terminated", "Software Program Error (Incorrect Results)", "Storage Capacity Problem", "Temperature Unacceptable", "Threshold Crossed", "Timing Problem", "Toxic Leak Detected", "Transmit Failure", "Transmitter Failure", "Underlying Resource Unavailable", "Version MisMatch", "Previous Alert Cleared", "Login Attempts Failed", "Software Virus Detected", "Hardware Security Breached", "Denial of Service Detected", "Security Credential MisMatch", "Unauthorized Access", "Alarm Received", "Loss of Pointer", "Payload Mismatch", "Transmission Error", "Excessive Error Rate", "Trace Problem", "Element Unavailable", "Element Missing", "Loss of Multi Frame", "Broadcast Channel Failure", "Invalid Message Received", "Routing Failure", "Backplane Failure", "Identifier Duplication", "Protection Path Failure", "Sync Loss or Mismatch", "Terminal Problem", "Real Time Clock Failure", "Antenna Failure", "Battery Charging Failure", "Disk Failure", "Frequency Hopping Failure", "Loss of Redundancy", "Power Supply Failure", "Signal Quality Problem", "Battery Discharging", "Battery Failure", "Commercial Power Problem", "Fan Failure", "Engine Failure", "Sensor Failure", "Fuse Failure", "Generator Failure", "Low Battery", "Low Fuel", "Low Water", "Explosive Gas", "High Winds", "Ice Buildup", "Smoke", "Memory Mismatch", "Out of CPU Cycles", "Software Environment Problem", "Software Download Failure", "Element Reinitialized", "Timeout", "Logging Problems", "Leak Detected", "Protection Mechanism Failure", "Protecting Resource Failure", "Database Inconsistency", "Authentication Failure", "Breach of Confidentiality", "Cable Tamper", "Delayed Information", "Duplicate Information", "Information Missing", "Information Modification", "Information Out of Sequence", "Key Expired", "Non-Repudiation Failure", "Out of Hours Activity", "Out of Service", "Procedural Error", "Unexpected Information"},
     MappingStrings{"Recommendation.ITU|X733.Probable cause", "Recommendation.ITU|M3100.probableCause", "ITU-IANA-ALARM-TC"},
     ModelCorrespondence{"CIM_AlertIndication.ProbableCauseDescription", "CIM_AlertIndication.EventID", "CIM_AlertIndication.EventTime"}
    ]
    uint16 ProbableCause;

     [Description("Provides additional information related to the ProbableCause."),
     ModelCorrespondence{"CIM_AlertIndication.ProbableCause"}
    ]
    string ProbableCauseDescription;

     [Description("Provides information on trending - trending up, down or no change."),
     ValueMap{"0", "1", "2", "3", "4"},
     Values{"Unknown", "Not Applicable", "Trending Up", "Trending Down", "No Change"},
     MappingStrings{"Recommendation.ITU|X733.TrendIndication"}
    ]
    uint16 Trending;

     [Description("Free form descriptions of the recommended actions to take to resolve the cause of the notification."),
     MappingStrings{"Recommendation.ITU|X733.Proposed repair actions"}
    ]
    string RecommendedActions[];

     [Description("An instrumentation or provider specific value that describes the underlying \"real-world\" event represented by the Indication. Two Indications with the same, non NULL EventID value are considered, by the creating entity, to represent the same event. The comparison of two EventID values is only defined for Alert Indications with identical, non NULL values of SystemCreateClassName, SystemName and ProviderName."),
     ModelCorrespondence{"CIM_AlertIndication.ProbableCause"}
    ]
    string EventID;

     [Description("The time and date the underlying event was first detected. If specified, this property MUST be set to NULL if the creating entity is not capable of providing this information. This value is based on the notion of local date and time of the Managed System Element generating the Indication."),
     ModelCorrespondence{"CIM_AlertIndication.ProbableCause"}
    ]
    datetime EventTime;

     [Description("The scoping System\'s CreationClassName for the Provider generating this Indication."),
     MaxLen(256)
    ]
    string SystemCreationClassName;

     [Description("The scoping System\'s Name for the Provider generating this Indication."),
     MaxLen(256)
    ]
    string SystemName;

     [Description("The name of the Provider generating this Indication."),
     MaxLen(256)
    ]
    string ProviderName;

};

// LSISSI_PhysicalElementLocation

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("PhysicalElementLocation associates a PhysicalElement with a Location object for inventory or replacement purposes.")
    ]
class LSISSI_PhysicalElementLocation : CIM_PhysicalElementLocation {
};

// LSISSI_ConcreteIdentity

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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\nIt 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 LSISSI_ConcreteIdentity : CIM_ConcreteIdentity {
};

// CIM_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(true),
     Description("The hardware worldwide unique ID."),
     MaxLen(256),
     ModelCorrespondence{"CIM_StorageHardwareID.IDType"}
    ]
    string StorageID;

     [Required(true),
     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;

};

// CIM_NetworkPortStatistics

    [Version("2.7.0"),
     Description("The NetworkPortStatistics class describes the statistics for the NetworkPort.")
    ]
class CIM_NetworkPortStatistics : CIM_StatisticalData {
    [Counter(true),
     Description("The total number of bytes transmitted, including framing characters."),
     Mappingstrings{"MIB.IETF|MIB-II.ifOutOctets", "MIF.DMTF|Network Adapter 802 Port|001.7"},
     Units("Bytes")
    ]
    uint64 BytesTransmitted;

     [Counter(true),
     Description("The total number of bytes received, including framing characters."),
     Mappingstrings{"MIB.IETF|MIB-II.ifInOctets", "MIF.DMTF|Network Adapter 802 Port|001.9"},
     Units("Bytes")
    ]
    uint64 BytesReceived;

     [Counter(true),
     Description("The total number of packets transmitted.")
    ]
    uint64 PacketsTransmitted;

     [Counter(true),
     Description("The total number of packets received.")
    ]
    uint64 PacketsReceived;

};

// CIM_MediaAccessStatData

    [Version("2.7.0"),
     Description("Statistics related to reading and writing at a specific MediaAccessDevice, or for a specific StorageExtent. The same class is used to represent this data - whether for the MediaAccessDevice (independent of the StorageExtent), OR for the Extent (independent of its AccessDevice). The element whose statistics are described is associated using the relationship, ElementStatisticalData. Note that this class models the same properties as MediaAccessStatInfo. This class, however, uses the simplified key mechanisms of its superclass, StatisticalData.")
    ]
class CIM_MediaAccessStatData : CIM_StatisticalData {
    [Counter(true),
     Description("The number of attempted read operations.")
    ]
    uint64 ReadOperations;

     [Counter(true),
     Description("The number of unrecoverable read operations.")
    ]
    uint64 UnrecoverableReadOperations;

     [Counter(true),
     Description("The number of attempted write operations.")
    ]
    uint64 WriteOperations;

     [Counter(true),
     Description("The number of unrecoverable write operations.")
    ]
    uint64 UnrecoverableWriteOperations;

     [Counter(true),
     Description("The number of recovered read operations.")
    ]
    uint64 RecoveredReadOperations;

     [Counter(true),
     Description("The number of recovered write operations.")
    ]
    uint64 RecoveredWriteOperations;

     [Counter(true),
     Description("The number of recovered seek operations.")
    ]
    uint64 RecoveredSeekOperations;

     [Counter(true),
     Description("The number of unrecoverable seek operations.")
    ]
    uint64 UnrecoverableSeekOperations;

};

// LSISSI_Location

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The Location class specifies the position and address of a PhysicalElement.")
    ]
class LSISSI_Location : CIM_Location {
};

// CIM_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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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(true),
     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;

};

// CIM_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[];

};

// CIM_ListenerDestinationCIMXML

    [Version("2.8.0"),
     Description("CIM_ListenerDestinationCIMXML describes the destination for CIM Export Messages to be delivered via CIM-XML."),
     Provider("internal:cim_listenerdestination")
    ]
class CIM_ListenerDestinationCIMXML : CIM_ListenerDestination {
    [Required(true),
     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;

};

// LSISSI_StorageProduct

    [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. \nNote 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 LSISSI_StorageProduct : CIM_Product {
};

// LSISSI_DiskDriveProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_DiskDriveProduct : CIM_Product {
};

// LSISSI_ControllerProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_ControllerProduct : CIM_Product {
};

// LSISSI_MiniHubProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_MiniHubProduct : CIM_Product {
};

// LSISSI_SFPProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_SFPProduct : CIM_Product {
};

// LSISSI_ChassisProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_ChassisProduct : CIM_Product {
    [MaxLen(30),
     Description("Vendor-unique, client-settable primary owner name.")
    ]
    string PrimaryOwnerName;

     [MaxLen(50),
     Description("Vendor-unique, client-settable primary owner contact information.")
    ]
    string PrimaryOwnerContact;

};

// LSISSI_ESMProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_ESMProduct : CIM_Product {
};

// LSISSI_PowerSupplyProduct

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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 LSISSI_PowerSupplyProduct : CIM_Product {
};

// CIM_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(true), 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. \nIf 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\nThis 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(true), Description("Reference to the created StorageSetting instance.")] CIM_StorageSetting REF NewSetting);
};

// 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: \nAsync: asynchronous copies may be created and maintained. \nSync: synchronous copies may be created and maintained. \nUnSyncAssoc: unsynchronized copies may be created and maintained. \nUnSyncUnAssoc: 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: \nInitialized: The replication relationship is known and unsynchronized, but time required to synchronize may be long. \nPrepared: The replication relationship is known and unsynchronized and the time required to synchronize will be short. \nSynchronized: 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_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 = 2;

     [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("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 a Privilege/Identity pair MUST be specified when CreateProtocolControllerWithPorts() is called. If false, then the Privilege/Identity pair in CreateProtocolControllerWithPorts() MUST NOT be set.")
    ]
    boolean ProtocolControllerRequiresAuthorizedIdentity = false;

     [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;

};

// LSISSI_ProtocolControllerForUnit

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ProtocolControllerForUnit : CIM_ProtocolControllerForUnit {
};

// LSISSI_ProtocolControllerAccessesUnit

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ProtocolControllerAccessesUnit : CIM_ProtocolControllerAccessesUnit {
};

// LSISSI_ProtocolControllerForPort

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ProtocolControllerForPort : CIM_ProtocolControllerForPort {
};

// LSISSI_HostedService

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_HostedService : CIM_HostedService {
};

// LSISSI_HostedCollection

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("HostedCollection defines a SystemSpecificCollection in the context of a scoping 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.")
    ]
class LSISSI_HostedCollection : CIM_HostedCollection {
};

// LSISSI_RealizesExtent

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_RealizesExtent : CIM_RealizesExtent {
};

// LSISSI_SharedSecretIsShared

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("This relationship associates a SharedSecretService with the SecretKey it verifies.")
    ]
class LSISSI_SharedSecretIsShared : CIM_SharedSecretIsShared {
};

// LSISSI_ComputerSystemPackage

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ComputerSystemPackage : CIM_ComputerSystemPackage {
};

// LSISSI_PackagedComponent

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Aggregation(true),
     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 LSISSI_PackagedComponent : CIM_PackagedComponent {
};

// LSISSI_PackageInChassis

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Aggregation(true),
     Description("A Chassis can contain other Packages, such as other Chassis and Cards. The PackageInChassis association makes explicit this relationship.")
    ]
class LSISSI_PackageInChassis : CIM_PackageInChassis {
};

// LSISSI_ComponentCS

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Composition(true),
     Aggregation(true),
     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\nWhen 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 LSISSI_ComponentCS : CIM_ComponentCS {
};

// LSISSI_StorageProcessorSystem

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageProcessorSystem : CIM_ComputerSystem {
    [Override("ElementName"),
     MaxLen(64),
     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;

     [Description("The size of the controller\'s cache memory in MB. ")
    ]
    uint64 CacheMemorySize;

     [Description("The size of the controller\'s CPU memory in MB. ")
    ]
    uint64 ProcessorMemorySize;

     [Description("Is controller manageable using supplied IP addresses?")
    ]
    boolean IsManageable;

     [Description("Vendor Unique property identifying the WWN of the Storage System thisStorage Processor is associated with.")
    ]
    string SystemName;

};

// LSISSI_StorageProcessorDevice

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Composition(true),
     Aggregation(true),
     Description("LogicalDevices may be aggregated by a System. This relationship is made explicit by the SystemDevice association.")
    ]
class LSISSI_StorageProcessorDevice : CIM_SystemDevice {
    [Min(1),
     Max(1),
     Description("The parent system in the Association."),
     Override("GroupComponent"),
     Key(true),
     Aggregate(true)
    ]
    LSISSI_StorageProcessorSystem REF GroupComponent;

};

// LSISSI_StorageSystem

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageSystem : CIM_ComputerSystem {
    boolean SupportsProvisioning = true;

     [Description("Client-settable number of bytes for the storage array cache block size. 4 KB is optimal for file system and database applications.16 KB is optimal for multimedia applications."),
     ValueMap{"4096", "16384"},
     Values{"4096", "16384"},
     Units("Bytes")
    ]
    uint64 CacheBlockSize;

     [Override("OperationalStatus"),
     Description("Indicates the current status of the storage system.  \n \"OK\" indicates that the storage system is fully redundant. \n\"Failed\" indicates that the storage system has lost redundancy. \n \"Degraded\" indicates that the storage system is operating in a degraded mode due to one or more drive failures. \n \"Needs Attention\" indicates that one or more components have been marked failed. \n\"Fixing, Needs Attention\" indicates that the storage system is in the process of recovering from a Needs Attention condition.  This status indicates that no physical components are currently marked failed but that some residual recovery activity, such as reconstruction, copyback, etc., is still in progress.  "),
     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[];

     [Override("ElementName"),
     MaxLen(30),
     Write(true),
     Description("Client-settable element name string which the client can use as a handle to the storage array.")
    ]
    string ElementName;

     [Description("Vendor-unique manufacturer. ")
    ]
    string Manufacturer;

     [Description("Vendor-unique Product ID. ")
    ]
    string ProductID;

     [Description("Vendor-unique management class name. ")
    ]
    string ManagementClassName;

     [Description("Vendor-unique time of last boot. ")
    ]
    datetime LastBootTime;

     [Description("Vendor-unique NVSRAM Version. ")
    ]
    string NVSRAMVersion;

     [Description("Vendor-unique demand flush amount. Specifies the amount of cache data that will be flushed to disk when a cache flush operation is initiated.  This value is specified as an integer in the range of 0 to 100 that represents the percentage of the controller\'s write cache data that can remain in the \'dirty\' or unflushed state.  When demand flush operations are started, data will be flushed from cache to disk until the overall amount of dirty data drops to or below the percentage specified by this value.  ")
    ]
    uint32 DemandFlushAmount;

     [Description("Vendor-unique demand flush threshold. Specifies the \'level of fullness\' of \'dirty\' data in the controller\'s write cache which, when reached, will cause the controller to begin flushing data from cache to disk.  This value is specified as a percentage, in the range of 0 to 100, of the overall write cache capacity of the controller.  After flushing begins, it will continue until enoughdata has been flushed to drop the percentage of dirty data to or below the value specified in the demandFlushAmount parameter described above.  ")
    ]
    uint32 DemandFlushThreshold;

     [Description("Vendor-unique maximum number of hot spares. The maximum number of hot spare drives that can be assigned.")
    ]
    uint32 MaxHotSpares;

     [Description("Vendor-unique array of cache block sizes. A variable length array in which each element specifies one of the supported cache block sizes (in bytes) that can be set on the controller.  "),
     ArrayType("Indexed")
    ]
    uint32 CacheBlockSizes[];

     [Description("Vendor-unique maximum number of expansion drives. The maximum number of drives that can be added, in a given operation, to an existing volume group to expand the capacity of the volume group.  ")
    ]
    uint32 MaxDCEDrives;

     [Description("Vendor-unique maximum read-ahead multiplier. The maximum multiplier value that can be specified when configuring the read-ahead parameter for a volume.  ")
    ]
    uint32 MaxReadAheadMultiplier;

     [Description("Vendor-unique media scan period. The current value of the media scan period for the storage array.  This value indicates the number of days over which a complete scan of the media will occur.  The array controller(s) will attempt to achieve this configured period on a best-effort basis, but certain operational factors may cause slight deviations from the configured value.  ")
    ]
    sint32 MediaScanPeriod;

     [Description("Vendor-unique minimum media scan period. The minimum supported period (in days) over which a complete media scan can be set to occur.  ")
    ]
    sint32 MinMediaScanPeriod;

     [Description("Vendor-unique maximum media scan period. The maximum supported period (in days) over which a complete media scan can be set to occur.  ")
    ]
    sint32 MaxMediaScanPeriod;

     [Description("Vendor-unique mappable LUN count. The maximum number of LUN addresses that are available for volume mapping operations.  The range of supported LUN values is thus 0 through mappableLUNCount-1.  ")
    ]
    sint32 MappableLUNCount;

     [Description("Vendor-unique partition count. The number of partitions supported by the controller.  ")
    ]
    sint32 MaxPartitionCount;

     [Description("Vendor-unique maximum mappings per volume. The maximum number of mappings allowed per volume.  ")
    ]
    sint32 MaxMappingsPerVolume;

     [Description("Vendor-unique maximum storage volumes. The maximum number of standard volumes allowed per array. ")
    ]
    sint32 MaxStorageVolumes;

     [Description("Vendor-unique maximum snapshots. The maximum number of snapshot volumes allowed per array. ")
    ]
    sint32 MaxSnapshots;

     [Description("Vendor-unique maximum snapshots per base. The maximum number of snapshots allowed on any given base volume. ")
    ]
    sint32 MaxSnapshotsPerBase;

     [Description("Vendor-unique minimum repository size. The minimum size of a repository volume in bytes. ")
    ]
    sint32 MinRepositorySize;

     [Description("Vendor-unique maximum mirrors. The maximum number of mirrored volumes allowed per array. ")
    ]
    sint32 MaxMirrors;

     [Description("Vendor-unique maximum volume copies. The maximum number of volume copies allowed per array. ")
    ]
    sint32 MaxVolCopys;

     [Description("Vendor-unique maximum concurrent background copies. The maximum number of background copies that can be active at any one time. ")
    ]
    sint32 MaxConcurrentBackgroundCopys;

     [Description("Vendor-unique volume transfer alert delay period. The volume transfer alert delay period in seconds in the range of 0 to 3600. ")
    ]
    sint32 VolXferAlertDelayPeriod;

     [Description("Vendor-unique esm software version. ")
    ]
    string ESMSoftwareVersion[];

};

// LSISSI_StorageSystemDevice

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Composition(true),
     Aggregation(true),
     Description("LogicalDevices may be aggregated by a System. This relationship is made explicit by the SystemDevice association.")
    ]
class LSISSI_StorageSystemDevice : CIM_SystemDevice {
    [Min(1),
     Max(1),
     Description("The parent system in the Association."),
     Override("GroupComponent"),
     Key(true),
     Aggregate(true)
    ]
    LSISSI_StorageSystem REF GroupComponent;

};

// LSISSI_HostedStoragePool

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Composition(true),
     Aggregation(true),
     Description("SystemStoragePool is a specialization of SystemComponent association that establishes that the StoragePool is defined in the context of the System.")
    ]
class LSISSI_HostedStoragePool : CIM_HostedStoragePool {
};

// CIM_AlertInstIndication

    [Indication(true),
     Version("2.6.0"),
     Description("A subclass of CIM_AlertIndication that embeds a CIM_Inst Indication. It is used when adding AlertIndication data to a LifeCycle Indication.")
    ]
class CIM_AlertInstIndication : CIM_AlertIndication {
    [Override("AlertType"),
     Description("The primary classification of the Indication, defaulted to 7, \"Model Change\", for this class. This is done because: 1) the primary purpose of AlertInstIndication is to add Alert data to a LifeCycle Indication; and 2) LifeCycle Indications deal with \'model changes\'."),
     Required(true),
     ValueMap{"1", "2", "3", "4", "5", "6", "7", "8"},
     Values{"Other", "Communications Alert", "Quality of Service Alert", "Processing Error", "Device Alert", "Environmental Alert", "Model Change", "Security Alert"},
     MappingStrings{"Recommendation.ITU|X733.Event type"}
    ]
    uint16 AlertType = 7;

     [Required(true),
     Description("Embeds the InstIndication that is part of this Alert Indication. Only the properties selected by the Indication Filter\'s Query are included."),
     EmbeddedObject(true)
    ]
    string IndObject;

};

// LSISSI_HostPortID

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_HostPortID : CIM_StorageHardwareID {
    [Override("ElementName"),
     MaxLen(30),
     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;

};

// CIM_GatewayPathID

    [Version("2.8.0"),
     Description("GatewayPathID extends StorageHardwareID to name a path segment defined by the end identities, HardwareID and GatewayID. The purpose is to describe Identity to allow access control to be applied to a particular path segment. Think of the element identified by GatewayPathID as a Gateway between a non-trusted world and a trusted world.")
    ]
class CIM_GatewayPathID : CIM_StorageHardwareID {
    [Required(true),
     Description("The ID representing the Gateway for a path segment from the element identified in the HardwareID property to the Gateway."),
     ModelCorrespondence{"CIM_GatewayPathID.GatewayIDType", "CIM_GatewayPathID.OtherGatewayIDType"}
    ]
    string GatewayID;

     [Required(true),
     Description("The type of the GatewayID property."),
     ValueMap{"1", "2", "3", "4"},
     Values{"Other", "PortWWN", "NodeWWN", "Hostname"},
     ModelCorrespondence{"CIM_GatewayPathID.GatewayID"}
    ]
    uint16 GatewayIDType;

     [Description("The gateway ID type when Gateway IDType is \"Other\"."),
     ModelCorrespondence{"CIM_GatewayPathID.GatewayID"}
    ]
    string OtherGatewayIDType;

};

// CIM_FCPortStatistics

    [Version("2.7.1000"),
     Description("FCPortStatistics is the statistics for the FCPort.")
    ]
class CIM_FCPortStatistics : CIM_NetworkPortStatistics {
    [Counter(true),
     Description("LIPCount is the number of LIP events that have occurred on an arbitrated loop.")
    ]
    uint64 LIPCount;

     [Counter(true),
     Description("NOSCount is the number of NOS events that have occurred on the switched fabric.")
    ]
    uint64 NOSCount;

     [Counter(true),
     Description("ErrorFrames is the number of frames that have been received in error.")
    ]
    uint64 ErrorFrames;

     [Counter(true),
     Description("DumpedFrames is the number of frames that were lost due to a lack of host buffers available.")
    ]
    uint64 DumpedFrames;

     [Counter(true),
     Description("LinkFailure is the number of times a link error has occurred. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 LinkFailures;

     [Counter(true),
     Description("Number of times that signal is lost on the Port since last reset of the Device. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 LossOfSignalCounter;

     [Counter(true),
     Description("Number of times that synchronization is lost on the Port since last reset of the Device. Synchronization is assumed lost after a timeout period (identified by the ReceiverTransmitterTimeout property) is exceeded. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 LossOfSyncCounter;

     [Counter(true),
     Description("Count of primitive sequence protocol errors detected at this port. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 PrimitiveSeqProtocolErrCount;

     [Counter(true),
     Description("Number of times that the CRC in a frame does not match the CRC computed by the receiver. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 CRCErrors;

     [Counter(true),
     Description("The number of transmission words that had an invalid character (8b10b code violation) in one or more of its characters, had a K28.5 (8b10b control) in its second, third or fourth character positions, and/or had an incorrect Beginning Running Disparity. This count is part of the Link Error Status Block (LESB).")
    ]
    uint64 InvalidTransmissionWords;

     [Counter(true),
     Description("The number of frames received that were shorter than 28 octets. The value of 28 is calculated based on an assumption of 24 header bytes plus 4 CRC bytes. The count does not include SOF/EOF bytes which are not data.")
    ]
    uint64 FramesTooShort;

     [Counter(true),
     Description("The number of frames received that were longer than 2140 octets. The value of 2140 is calculated based on an assumption of 24 header bytes plus 4 CRC bytes and 2112 bytes of payload.")
    ]
    uint64 FramesTooLong;

     [Counter(true),
     Description("Count of frames received with unknown addressing. An example is an unknown SID or DID. The SID or DID is not known to the routing algorithm.")
    ]
    uint64 AddressErrors;

     [Counter(true),
     Description("Count of occurrences when all input buffers of a port were full and outbound buffer-to-buffer credit transitioned to zero. There is no credit to provide to other side.")
    ]
    uint64 BufferCreditNotProvided;

     [Counter(true),
     Description("Count of transitions in/out of BBcredit zero state. The other side is not providing any credit.")
    ]
    uint64 BufferCreditNotReceived;

     [Counter(true),
     Description(" Count of invalid frame delimiters received at this port. An example is a frame with a class 2 start and a class 3 at the end.")
    ]
    uint64 DelimiterErrors;

     [Counter(true),
     Description("Count of disparity errors received at this port.")
    ]
    uint64 EncodingDisparityErrors;

     [Counter(true),
     Description("Count of Link resets. This is the number of LRs received.")
    ]
    uint64 LinkResetsReceived;

     [Counter(true),
     Description("Count of Link resets. This is the number of LRs transmitted.")
    ]
    uint64 LinkResetsTransmitted;

     [Counter(true),
     Description("Count of Multicast Frames or Packets received.")
    ]
    uint64 MulticastFramesReceived;

     [Counter(true),
     Description("Count of Multicast Frames or Packets transmitted.")
    ]
    uint64 MulticastFramesTransmitted;

     [Experimental(true),
     Counter(true),
     Description("FBSYFrames is the count of times that FBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|ErrorCounters|1.SWAPI_STATS_LBL_FBSY"}
    ]
    uint64 FBSYFrames;

     [Experimental(true),
     Counter(true),
     Description("PBSYFrames is the count of times that PBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|ErrorCounters|1.SWAPI_STATS_LBL_PBSY"}
    ]
    uint64 PBSYFrames;

     [Experimental(true),
     Counter(true),
     Description("FRJTFrames is the count of times that FRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|ErrorCounters|1.SWAPI_STATS_LBL_FRJT"}
    ]
    uint64 FRJTFrames;

     [Experimental(true),
     Counter(true),
     Description("PRJTFrames is the count of times that PRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|ErrorCounters|1.SWAPI_STATS_LBL_PRJT"}
    ]
    uint64 PRJTFrames;

     [Experimental(true),
     Counter(true),
     Description("RXClass1Frames is the count of class 1 frames received."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1RF"}
    ]
    uint64 RXClass1Frames;

     [Experimental(true),
     Counter(true),
     Description("TXClass1Frames is the count of class 1 frames transmitted."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1TF"}
    ]
    uint64 TXClass1Frames;

     [Experimental(true),
     Counter(true),
     Description("Class1FBSY is the count of times that FBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1FB"}
    ]
    uint64 Class1FBSY;

     [Experimental(true),
     Counter(true),
     Description("Class1PBSY is the count of times that PBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1PB"}
    ]
    uint64 Class1PBSY;

     [Experimental(true),
     Counter(true),
     Description("Class1FRJT is the count of times that FRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1FR"}
    ]
    uint64 Class1FRJT;

     [Experimental(true),
     Counter(true),
     Description("Class1PRJT is the count of times that PRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C1PR"}
    ]
    uint64 Class1PRJT;

     [Experimental(true),
     Counter(true),
     Description("RXClass2Frames is the count of class 2 frames received."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2RF"}
    ]
    uint64 RXClass2Frames;

     [Experimental(true),
     Counter(true),
     Description("TXClass2Frames is the count of class 2 frames transmitted."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2LF"}
    ]
    uint64 TXClass2Frames;

     [Experimental(true),
     Counter(true),
     Description("Class2FBSY is the count of times that FBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2FB"}
    ]
    uint64 Class2FBSY;

     [Experimental(true),
     Counter(true),
     Description("Class2PBSY is the count of times that PBSY was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2PB"}
    ]
    uint64 Class2PBSY;

     [Experimental(true),
     Counter(true),
     Description("Class2FRJT is the count of times that FRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2FR"}
    ]
    uint64 Class2FRJT;

     [Experimental(true),
     Counter(true),
     Description("Class2PRJT is the count of times that PRJT was returned to the port."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C2PR"}
    ]
    uint64 Class2PRJT;

     [Experimental(true),
     Counter(true),
     Description("RXClass3Frames is the count of class 3 frames received."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C3RF"}
    ]
    uint64 RXClass3Frames;

     [Experimental(true),
     Counter(true),
     Description("TXClass3Frames is the count of class 3 frames transmitted."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C3TF"}
    ]
    uint64 TXClass3Frames;

     [Experimental(true),
     Counter(true),
     Description("Class3FramesDiscarded is the count of class 3 frames that were discarded upon reception."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_C3DC"}
    ]
    uint64 Class3FramesDiscarded;

     [Experimental(true),
     Counter(true),
     Description("RXBroadcastFrames is the count of broadcast frames or packets received."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_RBCO"}
    ]
    uint64 RXBroadcastFrames;

     [Experimental(true),
     Counter(true),
     Description("TXBroadcastFrames is the count of broadcast frames or packets transmitted."),
     MappingStrings{"FC-SWAPI.T11|PerformanceCounters|1.SWAPI_STATS_LBL_TBCO"}
    ]
    uint64 TXBroadcastFrames;

};

// LSISSI_MediaAccessStatData

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Statistics related to reading and writing at a specific MediaAccessDevice, or for a specific StorageExtent. The same class is used to represent this data - whether for the MediaAccessDevice (independent of the StorageExtent), OR for the Extent (independent of its AccessDevice). The element whose statistics are described is associated using the relationship, ElementStatisticalData. Note that this class models the same properties as MediaAccessStatInfo. This class, however, uses the simplified key mechanisms of its superclass, StatisticalData.")
    ]
class LSISSI_MediaAccessStatData : CIM_MediaAccessStatData {
    [Description("Vendor-unique property: the total number of requests serviced."),
     Counter(true)
    ]
    uint64 TotalRequestsServiced;

     [Description("Vendor-unique property: the total number of blocks requested."),
     Counter(true)
    ]
    uint64 TotalBlocksRequested;

     [Description("Vendor-unique property: the total number of read blocks requested."),
     Counter(true)
    ]
    uint64 TotalReadBlocksRequested;

     [Description("Vendor-unique property: the total number of write blocks requested."),
     Counter(true)
    ]
    uint64 TotalWriteBlocksRequested;

     [Description("Vendor-unique property: the percent of read requests which is calculated as (ReadOperations * 100) / TotalRequestsServiced."),
     Counter(true)
    ]
    uint64 PercentReadRequests;

     [Description("Vendor-unique property: The average number of blocks requested."),
     Counter(true)
    ]
    uint64 AverageBlocksRequested;

     [Description("Vendor-unique property: The total number of large reads."),
     Counter(true)
    ]
    uint64 TotalLargeReads;

     [Description("Vendor-unique property: The total number of blocks requested for large reads."),
     Counter(true)
    ]
    uint64 TotalLargeReadBlocksRequested;

     [Description("Vendor-unique property: The total number of large writes."),
     Counter(true)
    ]
    uint64 TotalLargeWrites;

     [Description("Vendor-unique property: The total number of blocks requested for large writes."),
     Counter(true)
    ]
    uint64 TotalLargeWriteBlocksRequested;

     [Description("Vendor-unique property: The total number of calls to the cache manager to check to see if a host-initiated read request can be fully satisfied out of cache."),
     Counter(true)
    ]
    uint64 TotalCacheReadChecks;

     [Description("Vendor-unique property: The total number of times that a cache read check indicated that the request was satisfied out of cache."),
     Counter(true)
    ]
    uint64 TotalCacheReadCheckHits;

     [Description("Vendor-unique property: The total number of cache write requests."),
     Counter(true)
    ]
    uint64 TotalCacheWriteRequests;

};

// CIM_RedundancySet

    [Experimental(true),
     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.  \nNote 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 {
    [Required(true),
     Override("ElementName"),
     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;

};

// LSISSI_HostPortCollection

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nAn 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 LSISSI_HostPortCollection : CIM_SystemSpecificCollection {
    [Override("ElementName"),
     MaxLen(30),
     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;

};

// 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 {
    [Write(true),
     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;

     [Write(true),
     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;

     [Write(true),
     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;

     [Write(true),
     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[];

     [Write(true),
     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;

     [Write(true),
     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;

     [Write(true),
     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;

     [Write(true),
     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;

};

// LSISSI_PottedStorageSetting

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_PottedStorageSetting : CIM_StorageSetting {
};

// LSISSI_GeneratedStorageSetting

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_GeneratedStorageSetting : CIM_StorageSetting {
    [Write(true),
     Description("The vendor-unique, client-settable controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    string PreferredManager;

};

// LSISSI_StorageVolumeSetting

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageVolumeSetting : CIM_StorageSetting {
    [Description("The vendor-unique, controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    string PreferredManager;

};

// LSISSI_InitiatorSettingData

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_InitiatorSettingData : CIM_StorageClientSettingData {
};

// LSISSI_Privilege

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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\nNote that this class and its AuthorizedSubject/Target associations provide a short-hand, static mechanism to represent authorization policies.")
    ]
class LSISSI_Privilege : CIM_AuthorizedPrivilege {
};

// LSISSI_SharedSecret

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("CIM_SharedSecret is a secret (such as a password or the response to a challenge question) that is shared between a principal and a particular SharedSecret security service. Secrets may be in the form of a password used for initial authentication, or as with a session key, used as part of a message to verify the originator of the message. It is important to note that SharedSecret is not just a password, but rather is the password used with a particular security service.")
    ]
class LSISSI_SharedSecret : CIM_SharedSecret {
    [Override("Secret"),
     Write(true),
     MaxLen(30),
     Description("The secret known by the principal.")
    ]
    string Secret;

     [Override("Algorithm"),
     Description("Override Superclass property to add valuemap"),
     ValueMap{"0", "1"},
     Values{"HMAC-MD5", "PLAINTEXT"}
    ]
    string Algorithm = "0";

};

// CIM_PhysicalConnector

    [Version("2.8.0"),
     Description("The PhysicalConnector class represents any PhysicalElement that is used to connect to other Elements. Any object that can be used to connect and transmit signals or power between two or more PhysicalElements is a descendant (or member) of this class. For example, Slots and D-shell connectors are types of PhysicalConnectors.")
    ]
class CIM_PhysicalConnector : CIM_PhysicalElement {
    [Description("A free-form string describing the pin configuration and/or signal usage of a PhysicalConnector."),
     ModelCorrespondence{"CIM_PhysicalConnector.NumPhysicalPins"}
    ]
    string ConnectorPinout;

     [Deprecated{"CIM_PhysicalConnector.ConnectorGender", "CIM_PhysicalConnector.ConnectorElectricalCharacteristics", "CIM_PhysicalConnector.NumPhysicalPins", "CIM_PhysicalConnector.ConnectorLayout"},
     Description("An array of integers defining the type of PhysicalConnector. An array is specified to allow the description of \'combinations\' of Connector information. For example, one array entry could specify RS-232 (value=25), another DB-25 (value=23) and a third entry define the Connector as \"Male\" (value=2). \nThis single property is being deprecated in lieu of using separate properties to describe the various aspects of the connector. The separation allows for a more generic means of describing the connectors. Obsolete connectors were intentionally removed from the new list."),
     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", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122"},
     Values{"Unknown", "Other", "Male", "Female", "Shielded", "Unshielded", "SCSI (A) High-Density (50 pins)", "SCSI (A) Low-Density (50 pins)", "SCSI (P) High-Density (68 pins)", "SCSI SCA-I (80 pins)", "SCSI SCA-II (80 pins)", "Fibre Channel (DB-9, Copper)", "Fibre Channel (Optical Fibre)", "Fibre Channel SCA-II (40 pins)", "Fibre Channel SCA-II (20 pins)", "Fibre Channel BNC", "ATA 3-1/2 Inch (40 pins)", "ATA 2-1/2 Inch (44 pins)", "ATA-2", "ATA-3", "ATA/66", "DB-9", "DB-15", "DB-25", "DB-36", "RS-232C", "RS-422", "RS-423", "RS-485", "RS-449", "V.35", "X.21", "IEEE-488", "AUI", "UPT Category 3", "UPT Category 4", "UPT Category 5", "BNC", "RJ11", "RJ45", "Fiber MIC", "Apple AUI", "Apple GeoPort", "PCI", "ISA", "EISA", "VESA", "PCMCIA", "PCMCIA Type I", "PCMCIA Type II", "PCMCIA Type III", "ZV Port", "CardBus", "USB", "IEEE 1394", "HIPPI", "HSSDC (6 pins)", "GBIC", "DIN", "Mini-DIN", "Micro-DIN", "PS/2", "Infrared", "HP-HIL", "Access.bus", "NuBus", "Centronics", "Mini-Centronics", "Mini-Centronics Type-14", "Mini-Centronics Type-20", "Mini-Centronics Type-26", "Bus Mouse", "ADB", "AGP", "VME Bus", "VME64", "Proprietary", "Proprietary Processor Card Slot", "Proprietary Memory Card Slot", "Proprietary I/O Riser Slot", "PCI-66MHZ", "AGP2X", "AGP4X", "PC-98", "PC-98-Hireso", "PC-H98", "PC-98Note", "PC-98Full", "SSA SCSI", "Circular", "On Board IDE Connector", "On Board Floppy Connector", "9 Pin Dual Inline", "25 Pin Dual Inline", "50 Pin Dual Inline", "68 Pin Dual Inline", "On Board Sound Connector", "Mini-jack", "PCI-X", "Sbus IEEE 1396-1993 32 bit", "Sbus IEEE 1396-1993 64 bit", "MCA", "GIO", "XIO", "HIO", "NGIO", "PMC", "MTRJ", "VF-45", "Future I/O", "SC", "SG", "Electrical", "Optical", "Ribbon", "GLM", "1x9", "Mini SG", "LC", "HSSC", "VHDCI Shielded (68 pins)", "InfiniBand", "AGP8X"},
     MappingStrings{"MIF.DMTF|Bus Port|004.10"},
     ArrayType("Indexed"),
     ModelCorrespondence{"CIM_PhysicalConnector.OtherTypeDescription"}
    ]
    uint16 ConnectorType[];

     [Deprecated{"CIM_PhysicalConnector.ConnectorDescription"},
     Description("A string describing the Connector - used when the ConnectorType property is set to 1 (\"Other\"). OtherType Description should be set to NULL when ConnectorType is any value other than 1. \nThe use of this property is deprecated in lieu of Connector Description."),
     MappingStrings{"MIF.DMTF|Bus Port|004.11"},
     ModelCorrespondence{"CIM_PhysicalConnector.ConnectorType"}
    ]
    string OtherTypeDescription;

     [Description("Describes the gender of the connector."),
     ValueMap{"0", "2", "3"},
     Values{"Unknown", "Male", "Female"}
    ]
    uint16 ConnectorGender;

     [Description("Describes the electrical characteristic for this connector."),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Values{"Unknown", "Other", "Single Ended", "Differential", "Low Voltage Differential", "Optical", "Copper", "Shielded", "Unshielded"},
     ArrayType("Indexed"),
     ModelCorrespondence{"CIM_PhysicalConnector.OtherElectricalCharacteristics"}
    ]
    uint16 ConnectorElectricalCharacteristics[];

     [Description("A string describing the connector\'s electrical characteristics - used when the ConnectorElectricalCharacteristics property contains an entry of 1 (Other). OtherElectricalCharacteristics should be set to NULL when ConnectorElectricalCharacteristics does not contain an value of 1."),
     ArrayType("Indexed"),
     ModelCorrespondence{"CIM_PhysicalConnector.ConnectorElectricalCharacteristics"}
    ]
    string OtherElectricalCharacteristics[];

     [Description("Describes the number of physical pins (male/female) that are present on this connector."),
     ModelCorrespondence{"CIM_PhysicalConnector.ConnectorPinout"}
    ]
    uint32 NumPhysicalPins;

     [Description("Describes the type of packaging normally associated with this type of connector."),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"},
     Values{"Unknown", "Other", "RS232", "BNC", "RJ11", "RJ45", "DB9", "Slot", "SCSI High Density", "SCSI Low Density", "Ribbon"},
     ModelCorrespondence{"CIM_PhysicalConnector.ConnectorDescription"}
    ]
    uint16 ConnectorLayout;

     [Description("A string describing the Connector - used when the ConnectorLayout property is set to 1 (\"Other\"). Connector Description should be set to NULL when ConnectorLayout is any value other than 1."),
     MappingStrings{"MIF.DMTF|Bus Port|004.11"},
     ModelCorrespondence{"CIM_PhysicalConnector.ConnectorLayout"}
    ]
    string ConnectorDescription;

};

// LSISSI_ParentStoragePoolCapabilities

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ParentStoragePoolCapabilities : CIM_StorageCapabilities {
};

// LSISSI_StoragePoolCapabilities

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StoragePoolCapabilities : CIM_StorageCapabilities {
};

// LSISSI_StorageConfigurationCapabilities

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("A subclass of Capabilities that defines the Capabilities of a StorageConfigurationService. An instance of StorageConfigurationCapabilities is associated with a StorageConfigurationService using ElementCapabilities.")
    ]
class LSISSI_StorageConfigurationCapabilities : CIM_StorageConfigurationCapabilities {
};

// LSISSI_ProtocolControllerMaskingCapabilities

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("A subclass of Capabilities that defines the Masking-related capabilities of a ProtocolController.")
    ]
class LSISSI_ProtocolControllerMaskingCapabilities : CIM_ProtocolControllerMaskingCapabilities {
    [Override("InstanceID"),
     MaxLen(64),
     Description("LSISSI_StorageSystem.Name"),
     Key(true)
    ]
    string InstanceID;

};

// LSISSI_BackEndFCPortStatistics

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("FCPortStatistics is the statistics for the FCPort.")
    ]
class LSISSI_BackEndFCPortStatistics : CIM_FCPortStatistics {
};

// LSISSI_BackEndDeviceFCPortStatistics

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("FCPortStatistics is the statistics for the FCPort.")
    ]
class LSISSI_BackEndDeviceFCPortStatistics : CIM_FCPortStatistics {
};

// CIM_ExtraCapacitySet

    [Experimental(true),
     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;

};

// LSISSI_ExtendedStorageVolumeProvisioningSetting

    [Description("This class supports additional properties that are unique to LSI.")
    ]
class LSISSI_ExtendedStorageVolumeProvisioningSetting : CIM_StorageSettingWithHints {
    [Description("Read operations from the host will be stored in controller cache memory.")
    ]
    boolean EnableReadCaching;

     [Description("Write operations from the host will be stored in controller cache memory.")
    ]
    boolean EnableWriteCaching;

     [Description("Mirror cached data across two redundant controllers that have the same cache size.")
    ]
    boolean EnableWriteCachingWithMirroring;

     [Description("Cache read-ahead, or pre-fetch, allows the controller while reading and copying host-requested data blocks from disk into the cache, to copy additional blocks into the cache.  Valid values are 0 to 65535"),
     Units("Bytes")
    ]
    uint64 CacheReadAheadMultiplier;

     [Description("A segment is the amount of data, in kilobytes, that the controller writes on a single drive in a volume before writing data on the next drive.  Data blocks store 512 bytes of data and are the smallest units of storage.  The size of a segment determines how many data blocks it contains."),
     ValueMap{"8", "16", "32", "64", "128", "256"},
     Values{"8", "16", "32", "64", "128", "256"},
     Units("KB")
    ]
    uint64 SegmentSize;

     [Description("The user-assigned label for the volume.")
    ]
    string VolumeName;

};

// LSISSI_ThermalSensorComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_ThermalSensorComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the ThermalSensor component.  \n \"OK\" indicates that the ThermalSensor is working correctly. \n\"Stressed\" indicates that thermal sensor nominal temperature has exceeded. \n \"Error, Maximum Temp Exceeded\" indicates that thermal sensor maximum temperature has exceeded. \n \"Unknown\" indicates that the ThermalSensor has a status unknown to provider. \n"),
     ValueMap{"0", "2", "6", "7", "32779"},
     Values{"Unknown", "OK", "Error", "Non-Recoverable Error", "Maximum Temp Exceeded"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_ControllerComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_ControllerComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the controller component.  \n \"OK\" indicates that the controller is working correctly. \n\"Non-Recoverable Error\" indicates that the controller is not working. \n \"Error, RPA Parity Error\" indicates that the controller has a parity error. \n"),
     ValueMap{"2", "6", "7", "32777"},
     Values{"OK", "Error", "Non-Recoverable Error", "RPA Parity Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_GBICComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_GBICComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the GBIC component.  \n \"OK\" indicates that the GBIC is working correctly. \n\"Non-Recoverable Error\" indicates that the GBIC is not working. \n \"Unknown\" indicates that the GBIC has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7"},
     Values{"Unknown", "OK", "Non-Recoverable Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_ESMComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_ESMComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the ESM component.  \n \"OK\" indicates that the ESM is working correctly. \n\"Non-Recoverable Error\" indicates that the ESM is not working. \n \"Unknown\" indicates that the ESM has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7"},
     Values{"Unknown", "OK", "Non-Recoverable Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_SFPComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_SFPComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the SFP component.  \n \"OK\" indicates that the SFP is working correctly. \n\"Non-Recoverable Error\" indicates that the SFP is not working. \n \"Unknown\" indicates that the SFP has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7"},
     Values{"Unknown", "OK", "Non-Recoverable Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_DiskDriveComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_DiskDriveComponent : CIM_PhysicalPackage {
};

// LSISSI_PowerSupplyComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_PowerSupplyComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the PowerSupply component.  \n \"OK\" indicates that the PowerSupply is working correctly. \n\"Non-Recoverable Error\" indicates that the PowerSupply is not working. \n \"Unknown\" indicates that the PowerSupply has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7"},
     Values{"Unknown", "OK", "Non-Recoverable Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_MiniHubComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_MiniHubComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the ESM component.  \n \"OK\" indicates that the ESM is working correctly. \n\"Non-Recoverable Error\" indicates that the ESM is not working. \n \"Non-Recoverable Error, Unsupported\" indicates that the ESM status is not supported. \n \"Unknown\" indicates that the ESM has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7", "32778"},
     Values{"Unknown", "OK", "Non-Recoverable Error", "Unsupported"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_FanComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_FanComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the Fan component.  \n \"OK\" indicates that the Fan is working correctly. \n\"Non-Recoverable Error\" indicates that the Fan is not working. \n \"Unknown\" indicates that the Fan has a status unknown to provider. \n"),
     ValueMap{"0", "2", "7"},
     Values{"Unknown", "OK", "Non-Recoverable Error"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// CIM_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(true), Description("The connector to change the power setting for.")] CIM_PhysicalConnector REF Connector, [IN(true), Description("If TRUE, turn power on for the connector. If FALSE, turn power off.")] boolean PoweredOn);
};

// LSISSI_BatteryComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_BatteryComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the battery component.  \n \"OK\" indicates that the battery is working correctly. \n\"OK, Charging\" indicates that the battery is charging. \n\"OK, Near Expiration\" indicates that the battery is near expiration and needs to be replaced to ensure its proper function. \n\"Non-Recoverable Error\" indicates that the battery is not working. \n \"Lost Communication\" indicates that the battery is not present. \n\"Unknown\" indicates that the status of the battery is not known. \n\"No Contact\" indicates that the battery is not part of the configuration. \n"),
     ValueMap{"0", "2", "7", "12", "13", "32769", "32770"},
     Values{"Unknown", "OK", "Non-Recoverable Error", "No Contact", "Lost Communication", "Charging", "Near Expiration"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// LSISSI_UPSComponent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The PhysicalPackage class represents PhysicalElements that contain or host other components. Examples are a Rack enclosure or an adapter Card.")
    ]
class LSISSI_UPSComponent : CIM_PhysicalPackage {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the UPS component.  \n \"OK\" indicates that the UPS is working correctly. \n\"OK, On Battery\" indicates that the UPS is working correctly but is on battery. \n"),
     ValueMap{"2", "32780"},
     Values{"OK", "On Battery"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// 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", "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", "WORM", "Magneto-Optical", "DVD", "DVD-RW+", "DVD-RAM", "DVD-ROM", "DVD-Video", "Divx", "Floppy/Diskette", "Hard Disk", "Memory Card", "Hard Copy", "Clik Disk", "CD-RW", "CD-DA", "CD+", "DVD Recordable", "DVD-RW", "DVD-Audio", "DVD-5", "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", "Near Field Recording", "MiniQic", "Travan", "8mm Metal Particle", "8mm Advanced Metal Evaporate", "NCTP", "LTO Ultrium", "LTO Accelis", "9 Track Tape", "18 Track Tape", "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(true),
     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_ExtraCapacityGroup

    [Version("2.6.0"),
     Description("A class derived from RedundancyGroup indicating that the aggregated elements have more capacity or capability than is needed. An example of this type of redundancy is the installation of N+1 power supplies or fans in a system.")
    ]
class CIM_ExtraCapacityGroup : CIM_RedundancyGroup {
    [Description("MinNumberNeeded indicates the smallest number of elements that must be operational in order to have redundancy. For example, in an N+1 redundancy relationship, the MinNumberNeeded property should be set equal to N.")
    ]
    uint32 MinNumberNeeded;

     [Description("Boolean indicating whether load balancing is supported by the ExtraCapacityGroup.")
    ]
    boolean LoadBalancedGroup;

};

// LSISSI_RedundancySet

    [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 LSISSI_RedundancySet : CIM_RedundancyGroup {
};

// LSISSI_DiskDriveSoftwareIdentity

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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. \nNote 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 LSISSI_DiskDriveSoftwareIdentity : CIM_SoftwareIdentity {
};

// LSISSI_ControllerSoftwareIdentityAppware

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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. \nNote 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 LSISSI_ControllerSoftwareIdentityAppware : CIM_SoftwareIdentity {
};

// LSISSI_ControllerSoftwareIdentityBootware

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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. \nNote 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 LSISSI_ControllerSoftwareIdentityBootware : CIM_SoftwareIdentity {
};

// LSISSI_SoftwareIdentity

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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. \nNote 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. \nNote 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 LSISSI_SoftwareIdentity : CIM_SoftwareIdentity {
};

// CIM_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(true),
     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> \nWhere <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(true),
     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.)"),
     MaxLen(1024)
    ]
    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: \nNew (2) indicates that the job has never been started. \nStarting (3) indicates that the job is moving from the \'New\', \'Suspended\', or \'Service\' states into the \'Running\' state. \nRunning (4) indicates that the Job is running. \nSuspended (5) indicates that the Job is stopped, but may be restarted in a seamless manner. \nShutting Down (6) indicates the job is moving to a \'Completed\', \'Terminated\', or \'Killed\' state. \nCompleted (7) indicates that the job has completed normally. \nTerminated (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. \nKilled (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. \nException (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. \nService (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. \nIf 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(true), Description("Changes the state of a job. \nStart (2) changes the state to \'Running\'. \nSuspend (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. \nTerminate (4) stops the job cleanly, saving data, preserving state, and shutting down all underlying processes in an orderly manner. \nKill (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(true), 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. \nIf 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);
};

// LSISSI_ParentStoragePool

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ParentStoragePool : CIM_StoragePool {
    [Override("ElementName"),
     MaxLen(64),
     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;

};

// LSISSI_StoragePool

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StoragePool : CIM_StoragePool {
    [Override("ElementName"),
     MaxLen(30),
     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("RemainingManagedSpace"),
     Experimental(true),
     Description("The amount of raw storage (in bytes) in the largest remaining free extent in this volume group."),
     Units("Bytes"),
     ModelCorrespondence{"StoragePool.TotalManagedSpace", "AllocatedFromStoragePool.SpaceConsumed"},
     Required(true)
    ]
    uint64 RemainingManagedSpace;

     [Override("OperationalStatus"),
     Description("Indicates the current status of the volume group.  \n \"OK\" indicates that volume group is online. \"Stopped, Offline\" indicates that the volume group is currently offline.  A volume group can be taken offline in preparation for removing its drives and transporting them to another storage array. \n "),
     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("Vendor-unique property: A boolean.  False means it was created by an SMI client.")
    ]
    boolean CreatedOutsideSMIS;

     [Description("Vendor-unique property: Represents the total logical space on this StoragePool.")
    ]
    uint64 TotalLogicalSpace;

};

// LSISSI_StorageSystemExtraCapacitySet

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageSystemExtraCapacitySet : CIM_ExtraCapacitySet {
};

// LSISSI_PhysicalMedia

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_PhysicalMedia : CIM_PhysicalMedia {
};

// CIM_Battery

    [Version("2.7.0"),
     Description("Capabilities and management of the Battery LogicalDevice. This class applies to both batteries in Laptop Systems and other internal/external batteries, such as used in, or as UPSs.")
    ]
class CIM_Battery : CIM_LogicalDevice {
    [Description("Description of the Battery\'s charge status. Values such as \"Fully Charged\" (value=3) or \"Partially Charged\" (11) can be specified. The value, 10, is not valid in the CIM Schema since in DMI it represents that no battery is installed. In this case, this object should not be instantiated."),
     ValueMap{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"},
     Values{"Other", "Unknown", "Fully Charged", "Low", "Critical", "Charging", "Charging and High", "Charging and Low", "Charging and Critical", "Undefined", "Partially Charged"},
     MappingStrings{"MIF.DMTF|Portable Battery|003.14"}
    ]
    uint16 BatteryStatus;

     [Description("TimeOnBattery indicates the elapsed time in seconds since the ComputerSystem, UPS, ... last switched to battery power, or the time since the System or UPS was last restarted, whichever is less. Zero shall be returned if the Battery is \'on line\'."),
     Units("Seconds")
    ]
    uint32 TimeOnBattery;

     [Description("EstimatedRunTime is an estimate in minutes of the time to battery charge depletion under the present load conditions if the utility power is off, or lost and remains off, or a Laptop is disconnected from a power source."),
     Units("Minutes"),
     MappingStrings{"MIF.DMTF|Portable Battery|003.15"}
    ]
    uint32 EstimatedRunTime;

     [Description("An estimate of the percentage of full charge remaining."),
     Units("Percent"),
     Gauge(true)
    ]
    uint16 EstimatedChargeRemaining;

     [Description("An enumeration that describes the Battery\'s chemistry."),
     ValueMap{"1", "2", "3", "4", "5", "6", "7", "8"},
     Values{"Other", "Unknown", "Lead Acid", "Nickel Cadmium", "Nickel Metal Hydride", "Lithium-ion", "Zinc air", "Lithium Polymer"},
     MappingStrings{"MIF.DMTF|Portable Battery|003.7"}
    ]
    uint16 Chemistry;

     [Description("The design capacity of the battery in mWatt-hours. If this property is not supported, enter 0."),
     Units("MilliWattHours"),
     MappingStrings{"MIF.DMTF|Portable Battery|003.8"}
    ]
    uint32 DesignCapacity;

     [Description("The full charge capacity of the battery in mWatt-hours. Comparison of this value to the Battery DesignCapacity determines when the Battery requires replacement. A Battery\'s end of life is typically when the FullCharge Capacity falls below 80% of the DesignCapacity. If this property is not supported, enter 0."),
     Units("MilliWattHours"),
     MappingStrings{"MIF.DMTF|Portable Battery|003.11"}
    ]
    uint32 FullChargeCapacity;

     [Description("The design voltage of the battery in mVolts. If this attribute is not supported, enter 0."),
     Units("MilliVolts"),
     MappingStrings{"MIF.DMTF|Portable Battery|003.9"}
    ]
    uint64 DesignVoltage;

     [Description("The Smart Battery Data Specification version number supported by this Battery. If the Battery does not support this function, the value should be left blank."),
     MaxLen(64),
     MappingStrings{"MIF.DMTF|Portable Battery|003.10"}
    ]
    string SmartBatteryVersion;

     [Description("The remaining time to charge the battery fully in minutes at the current charging rate and usage."),
     Units("Minutes"),
     MappingStrings{"MIF.DMTF|Portable Battery|003.16"}
    ]
    uint32 TimeToFullCharge;

     [Description("Indicates the Battery\'s expected lifetime in minutes, assuming that the Battery is fully charged. This property represents the total expected life of the Battery, not its current remaining life, which is indicated by the EstimatedRunTime property."),
     Units("Minutes")
    ]
    uint32 ExpectedLife;

     [Description("MaxRechargeTime indicates the maximum time, in minutes, to fully charge the Battery. This property represents the time to recharge a fully depleted Battery, not the current remaining charging time, which is indicated in the TimeToFullCharge property."),
     Units("Minutes")
    ]
    uint32 MaxRechargeTime;

};

// CIM_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\nWhy 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;

};

// CIM_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(true), 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, [IN(false), OUT(true), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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(true), OUT(true), 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(true), 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(true), 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(true), OUT(true), 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(true), 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(true), 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, [IN(false), OUT(true), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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(true), OUT(true), 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(true), 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(true), OUT(true), 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([IN(false), OUT(true), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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([IN(false), OUT(true), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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(true), 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, [IN(false), OUT(true), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [Required(true), IN(true), Description("The source storage object which may be a StorageVolume or storage object.")] CIM_LogicalElement REF SourceElement, [IN(false), OUT(true), Description("Reference to the created target storage element (i.e., the replica).")] CIM_LogicalElement REF TargetElement, [IN(true), Description("The definition for the StorageSetting to be maintained by the target storage object (the replica).")] CIM_StorageSetting REF TargetSettingGoal, [IN(true), 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(true), Description("CopyType describes the type of copy that will be made. Values are: \nAsync: Create and maintain an asynchronous copy of the source. \nSync: Create and maintain a synchronized copy of the source. \nUnSyncAssoc: Create an unsynchronized copy and maintain an association to the source. \nUnSyncUnAssoc: 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(true), Description("Operation describes the type of modification to be made to the replica. Values are: \nDetach: \'Forget\' the synchronization between two storage objects. Start to treat the objects as independent. \nFracture: 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. \nResync Replica: Re-establish the synchronization of a replica. This will negate the action of a previous Fracture operation. \nRestore from Replica: Renew the contents of the original storage object from a replica. \nPrepare: 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. \nUnprepare: Clear a prepared state if a Prepare is not to be followed by a Resync operation. \nQuiesce: Some applications require notification so that they can ready the link for an operation. For example flush any cached data or buffered changes. \nUnquiesce: Take the link from the quiesced state (without executing the intended operation. \nReset To Sync: Change the CopyType of the association to Sync (e.g., from the Async CopyType). \nReset 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, [IN(false), OUT(true), Description("Reference to the job (may be null if the task completed).")] CIM_ConcreteJob REF Job, [IN(true), Description("The referenced to the StorageSynchronized association describing the storage source/replica relationship.")] CIM_StorageSynchronized REF Synchronization);
     [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([IN(false), OUT(true), Description("Reference to the job (may be null if the task completed).")] CIM_ConcreteJob REF Job, [Required(true), IN(true), Description("The source storage object which may be a StorageVolume or other storage object.")] CIM_ManagedElement REF SourceElement, [IN(true), Description("Reference to the target storage element (i.e., the replica).")] CIM_ManagedElement REF TargetElement, [IN(true), Description("CopyType describes the type of Synchronized relationship that will be created. Values are: \nAsync: Create and maintain an asynchronous copy of the source. \nSync: Create and maintain a synchronized copy of the source. \nUnSyncAssoc: Create an unsynchronized copy and maintain an association to the source. \nUnSyncUnAssoc: 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);
};

// CIM_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. \nIf 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(true), Description("The string to be used in the ElementName of the new ProtocolController."), ModelCorrespondence{"CIM_ProtocolController.ElementName"}] string ElementName, [IN(true), 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(true), Description("The protocol type for the new ProtocolController."), ValueMap{"0", "1", "2"}, Values{"Unknown", "Other", "SCSI"}, ModelCorrespondence{"CIM_SCSIProtocolController"}] uint16 Protocol, [IN(true), 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. \nNote: 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. \nNote: 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(true), 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(true), Description("The ProtocolController to be deleted.")] CIM_ProtocolController REF ProtocolController, [IN(true), 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(true), 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(true), Description("The ProtocolController instance.")] CIM_ProtocolController REF ProtocolController, [IN(true), Description("The LogicalDevice instance to attach.")] CIM_LogicalDevice REF Device, [IN(true), OUT(true), 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(true), Description("The ProtocolController instance.")] CIM_ProtocolController REF ProtocolController, [IN(true), Description("The LogicalDevice instance to detach.")] CIM_LogicalDevice REF Device);
};

// LSISSI_DeviceDiscoveryService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_DeviceDiscoveryService : CIM_Service {
    [Description("An attempt to discover the device at the host name/IP address occurs when this method is called or when the CIMOM starts after this method is called.  If the name cannot be resolved to an IP address, no storage array discovery is performed for this name.  This method always returns Job Completed with No ErrorHostNameOrIPAddr - An IP address or host name from which an IP address can   be resolved on the local subnet.  The name/address can be of a directly managed or host-agent managed (in-band) device.")
    ]
    uint16 addDevice([IN(true), Required(true)] string HostNameOrIPAddr);
     [Description("Sets AutomaticDiscovery to true in the default ProviderConfig instance.  Automatic discovery is initiated and completes before the method returns.  This may be a long running operation.  This method always returns Job Completed with No Error.")
    ]
    uint16 enableAutomaticDiscovery();
     [Description("If static discovery data matches the HostNameOrIPAddr parameter, it is deleted.  Instance data on any storage arrays discovered with the host name/IP address are no longer returned to the client.  This method always returns Job Completed with No Error.")
    ]
    uint16 removeDevice([IN(true), Required(true)] string HostNameOrIPAddr);
     [Description("Sets AutomaticDiscovery to false in the default ProviderConfig instance.  Storage arrays discovered with automatic discovery will continue to be managed until storage array discovery is performed again (manually or when the CIMOM is restarted).  This method always returns Job Completed with No Error.")
    ]
    uint16 disableAutomaticDiscovery();
     [Description("Returns an array of host names/IP addresses that were specified on previous calls to AddDevice. HostNameOrIPAddrs - An array of Strings with the host name or IP addresses specified by previous calls to the AddDevice method")
    ]
    uint16 listDiscoveryDevices([OUT(true)] string HostNameOrIPAddrs[]);
     [Description("Returns true if autodiscovery is enabled, and false if it is disabled.")
    ]
    uint16 isAutomaticDiscoveryEnabled([OUT(true)] boolean enabled);
};

// LSISSI_VolumeCopyJob

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_VolumeCopyJob : CIM_ConcreteJob {
};

// LSISSI_StoragePoolRAIDMigrationJob

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StoragePoolRAIDMigrationJob : CIM_ConcreteJob {
};

// LSISSI_StorageVolumeExpansionJob

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageVolumeExpansionJob : CIM_ConcreteJob {
};

// LSISSI_StoragePoolExpansionJob

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StoragePoolExpansionJob : CIM_ConcreteJob {
};

// LSISSI_Chassis

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_Chassis : CIM_Chassis {
    [Override("OperationalStatus"),
     Description("Indicates the current status of the chassis.  \n \"Error, Tray ID Mismatch\" indicates that the ID\'s on the ESM\'s do not match. \n\"Error, Tray ID Conflict\" indicates that the tray ID conflicts with that of another tray. \n \"Error, ESM Version Mismatch\" indicates that the ESM firmware versions do not match. \n\"Error, ESM Miswire\" indicates that the tray has an ESM join miswire. \n \"Error, Drive Mini Hub Speed Mismatch\" indicates that the tray has a drive-side minihub speed mismatch. \n\"Non-Recoverable Error, Unsupported Tray\" indicates that the tray is an unrecognized/unsupported hardware type. \n\"OK\"No chassis errors encountered . \n"),
     ValueMap{"32771", "32772", "32773", "32774", "32775", "32776"},
     Values{"Tray ID Mismatch", "Tray ID Conflict", "ESM Version Mismatch", "ESM Miswire", "Drive Mini Hub Speed Mismatch", "Unsupported Tray"},
     ModelCorrespondence{"CIM_ManagedSystemElement.StatusDescriptions"},
     ArrayType("Indexed")
    ]
    uint16 OperationalStatus[];

};

// CIM_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;

};

// LSISSI_Battery

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Capabilities and management of the Battery LogicalDevice. This class applies to both batteries in Laptop Systems and other internal/external batteries, such as used in, or as UPSs.")
    ]
class LSISSI_Battery : CIM_Battery {
    [Description("The vendor-unique property for battery age.")
    ]
    uint32 BatteryAge;

     [Description("The vendor-unique property for battery life remaining in days.")
    ]
    uint32 BatteryLifeRemaining;

};

// CIM_PortController

    [Version("2.8.0"),
     Description("PortController is a logical device corresponding to a hardware network port controller. Port controllers provide various features depending on their types and versions.")
    ]
class CIM_PortController : CIM_Controller {
    [Description("The type or model of the port controller. Specific values will be enumerated in a later release of this schema. When set to 1 (\"Other\"), the related property OtherControllerType contains a string description of the controller\'s type."),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Values{"Unknown", "Other", "Ethernet", "IB", "FC", "FDDI", "ATM", "Token Ring", "Frame Relay"},
     ModelCorrespondence{"CIM_PortController.OtherControllerType"}
    ]
    uint16 ControllerType;

     [Description("A string value for controller types not captured by the ControllerType enumeration. This should only be used when the value of the ControllerType property is set to 1, \"Other\"."),
     ModelCorrespondence{"CIM_PortController.ControllerType"}
    ]
    string OtherControllerType;

     [Description("The revision number of the controller.")
    ]
    uint16 ControllerVersion;

};

// CIM_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"},
     MaxLen(1024)
    ]
    string Name;

     [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;

};

// LSISSI_DiskExtent

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_DiskExtent : CIM_StorageExtent {
    [Override("ElementName"),
     MaxLen(64),
     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;

};

// LSISSI_StoragePoolExtent

    [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 LSISSI_StoragePoolExtent : CIM_StorageExtent {
    [Override("ElementName"),
     MaxLen(64),
     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;

};

// CIM_DiskDrive

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

// CIM_SCSIProtocolController

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

// CIM_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(true),
     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 = 2;

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

     [Deprecated{"CIM_CIMXMLCommunicationMechanism.Version"},
     Required(true),
     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(true),
     Description("Describes whether the CIM Server is strictly validating (validates the XML document against the DTD) or not (loosely validating).")
    ]
    boolean CIMValidated;

};

// LSISSI_StorageConfigurationService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageConfigurationService : CIM_StorageConfigurationService {
    [Override("CreateOrModifyStoragePool"),
     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(true), 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(true), IN(false), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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(true), OUT(true), 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(true), Description("Array of strings containing representations of references to StorageExtent instances that are used to create the Pool or modify the source extents. Only one InPool is supported, and it must be the primordial pool.")] string InPools[], [IN(true), 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(true), OUT(true), 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);
     [Override("CreateOrModifyElementFromStoragePool"),
     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(true), 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(true), Description("Enumeration indicating the type of element being created or modified. In this method, the ElementType must be a StorageVolume"), ValueMap{"2"}, Values{"StorageVolume"}] uint16 ElementType, [OUT(true), IN(false), Description("Reference to the job (may be null if job completed).")] CIM_ConcreteJob REF Job, [IN(true), 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(true), OUT(true), 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(true), 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(true), OUT(true), 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);
};

// LSISSI_ControllerConfigurationService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("The ControllerConfigurationService provides methods that allow a client to manipulate LUN Masking in a storage system.")
    ]
class LSISSI_ControllerConfigurationService : CIM_ControllerConfigurationService {
};

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

// CIM_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"},
     ModelCorrespondence{"CIM_NetworkPort.OtherNetworkPortType"}
    ]
    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[];

};

// LSISSI_ESM

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("PortController is a logical device corresponding to a hardware network port controller. Port controllers provide various features depending on their types and versions.")
    ]
class LSISSI_ESM : CIM_PortController {
    boolean NonredundantAccess;

     uint32 WorkingChannel;

};

// LSISSI_SnapshotVolume

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_SnapshotVolume : CIM_StorageVolume {
    [Write(true),
     Override("ElementName"),
     MaxLen(30),
     Description("The client-settable symbol label associated with the volume.")
    ]
    string ElementName;

     [Override("OperationalStatus"),
     Description("Indicates the current status of the storage volume.  \n \"OK\" indicates that volume group is online and operational. \n\"Stopped, Offline\" indicates that the storage volume is currently offline.  A storage volume can be taken offline in preparation for removing its drives and transporting them to another storage array. \n \"Degraded\" indicates that the storage volume is operating in a degraded mode due to one or more drive failures.\n \"Failed\" indicates that the volume has been marked failed due to one or more drive failures. \n\"Stressed, Inconsistent Parity\" indicates that the volume has been marked impaired due to the detection of inconsistent parity during a media scan operation."),
     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("The vendor-unique controller slot within the tray that currently owns, i.e. manages, this volume.  Host I/O access to the volumes is permitted only through the controller that is the current owning manager.")
    ]
    uint32 OwningController;

     [Description("The vendor-unique, client-settable controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    uint32 PreferredController;

     [Description("The vendor-unique, current controller slot within the tray that is the current manager of the volume.  The current manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the current manager and switch the ownership back to it.  ")
    ]
    string CurrentManager;

     [Write(true),
     Description("The vendor-unique, client-settable controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    string PreferredManager;

     [Description("The vendor-unique, client-settable value that indicates whether the controller is allowed to perform write-back caching when there is no battery backup protection available.  \'True\' indicates that the controller is allowed to use write-back caching of dirty data even when the cache memory\'s battery backup protection is not available or not operational.  \'False\' indicates that any problems with the battery backup protection of the write cache will cause the controller to suspend all write-back caching operations for the volume. ")
    ]
    boolean CacheWithOutBattery;

     [Description("The vendor-unique, client-settable value that determines whether write-back caching is affected by the state of the UPS.  \'True\' indicates that all dirty data in the write cache will be flushed immediately and further write-back caching will be disabled if the controller detects that a UPS unit has switched from standard power to battery backup.  \'False\' indicates that write-back caching is not impacted by the stateof the UPS. ")
    ]
    boolean EnterpriseCacheDump;

     [Description("Vendor-unique value that indicates whether the cache mirroring option is active for the volume\'s data.")
    ]
    boolean MirrorActive;

     [Description("The vendor-unique, client-settable value that indicates whether the cache mirroring feature is currently enabled for this volume.  It is possible that the MirrorEnable and MirrorActive values differ.  This may occur, for example, if the alternate controller is removed or failed. ")
    ]
    boolean MirrorEnable;

     [Description("Vendor-unique value that indicates whether read caching is active for the volume. ")
    ]
    boolean ReadCacheActive;

     [Description("The vendor-unique, client-settable value that indicates whether read caching is enabled for the volume.  Note that this value may not match the ReadCacheActive setting in cases where problems with the controller cache or its battery backup have been detected.")
    ]
    boolean ReadCacheEnable;

     [Description("Vendor-unique value that indicates whether write-back caching is active for the volume. ")
    ]
    boolean WriteCacheActive;

     [Description("The vendor-unique, client-settable value that indicates whether write-back caching is enabled for the volume.  Note that this value may not match the WriteCacheActive setting in cases where problems with the controller cache or its battery backup have been detected. ")
    ]
    boolean WriteCacheEnable;

     [Description("The value that determines the amount of read-ahead data to be fetched and stored in  the controller\'s cache when servicing a read request to this volume.  The value is a multiplier that is applied to the amount of data that is requested in the read IO operation to determine the read-ahead amount. Valid values are 0 to 65535"),
     Units("Bytes")
    ]
    uint64 ReadAheadMultiplier;

     [Description("A segment is the amount of data, in kilobytes, that the controller writes on a single drive in a volume before writing data on the next drive.  Data blocks store 512 bytes of data and are the smallest units of storage.The size of a segment determines how many data blocks it contains."),
     Units("KB")
    ]
    uint64 SegmentSize;

     [Description("Vendor unique boolean: Set to true if there are any LUN mappings to this StorageVolume.")
    ]
    boolean isAssigned;

     [Description("Vendor unique string: The identifier of the volume group in which the volume resides.")
    ]
    string PoolId;

     [Description("Vendor unique string The RAID level for which this volume is configured.")
    ]
    string RaidLevel;

     [Description("Test variable to see if a vector of CIMInstances can be stored as a String[]")
    ]
    string CIMInstances[];

};

// LSISSI_StorageVolume

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_StorageVolume : CIM_StorageVolume {
    [Write(true),
     Override("ElementName"),
     MaxLen(30),
     Description("The client-settable symbol label associated with the volume.")
    ]
    string ElementName;

     [Override("OperationalStatus"),
     Description("Indicates the current status of the storage volume.  \n \"OK\" indicates that volume group is online and operational. \n\"Stopped, Offline\" indicates that the storage volume is currently offline.  A storage volume can be taken offline in preparation for removing its drives and transporting them to another storage array. \n \"Degraded\" indicates that the storage volume is operating in a degraded mode due to one or more drive failures.\n \"Failed\" indicates that the volume has been marked failed due to one or more drive failures. \n\"Stressed, Inconsistent Parity\" indicates that the volume has been marked impaired due to the detection of inconsistent parity during a media scan operation."),
     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("The vendor-unique controller slot within the tray that currently owns, i.e. manages, this volume.  Host I/O access to the volumes is permitted only through the controller that is the current owning manager.")
    ]
    uint32 OwningController;

     [Description("The vendor-unique, client-settable controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    uint32 PreferredController;

     [Description("The vendor-unique, current controller slot within the tray that is the current manager of the volume.  The current manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the current manager and switch the ownership back to it.  ")
    ]
    string CurrentManager;

     [Write(true),
     Description("The vendor-unique, client-settable controller slot within the tray that is the preferred manager of the volume.  The preferred manager is tracked independently of the current manager since the current manager may be switched dynamically as a result of a host-based, multi-path transition.  Later, when the error conditions that cause a multi-path transition have been corrected, it is still possible to determine the preferred manager and switch the ownership back to it.  ")
    ]
    string PreferredManager;

     [Description("The vendor-unique, client-settable value that indicates whether the controller is allowed to perform write-back caching when there is no battery backup protection available.  \'True\' indicates that the controller is allowed to use write-back caching of dirty data even when the cache memory\'s battery backup protection is not available or not operational.  \'False\' indicates that any problems with the battery backup protection of the write cache will cause the controller to suspend all write-back caching operations for the volume. ")
    ]
    boolean CacheWithOutBattery;

     [Description("The vendor-unique, client-settable value that determines whether write-back caching is affected by the state of the UPS.  \'True\' indicates that all dirty data in the write cache will be flushed immediately and further write-back caching will be disabled if the controller detects that a UPS unit has switched from standard power to battery backup.  \'False\' indicates that write-back caching is not impacted by the stateof the UPS. ")
    ]
    boolean EnterpriseCacheDump;

     [Description("Vendor-unique value that indicates whether the cache mirroring option is active for the volume\'s data.")
    ]
    boolean MirrorActive;

     [Description("The vendor-unique, client-settable value that indicates whether the cache mirroring feature is currently enabled for this volume.  It is possible that the MirrorEnable and MirrorActive values differ.  This may occur, for example, if the alternate controller is removed or failed. ")
    ]
    boolean MirrorEnable;

     [Description("Vendor-unique value that indicates whether read caching is active for the volume. ")
    ]
    boolean ReadCacheActive;

     [Description("The vendor-unique, client-settable value that indicates whether read caching is enabled for the volume.  Note that this value may not match the ReadCacheActive setting in cases where problems with the controller cache or its battery backup have been detected.")
    ]
    boolean ReadCacheEnable;

     [Description("Vendor-unique value that indicates whether write-back caching is active for the volume. ")
    ]
    boolean WriteCacheActive;

     [Description("The vendor-unique, client-settable value that indicates whether write-back caching is enabled for the volume.  Note that this value may not match the WriteCacheActive setting in cases where problems with the controller cache or its battery backup have been detected. ")
    ]
    boolean WriteCacheEnable;

     [Description("The value that determines the amount of read-ahead data to be fetched and stored in  the controller\'s cache when servicing a read request to this volume.  The value is a multiplier that is applied to the amount of data that is requested in the read IO operation to determine the read-ahead amount. Valid values are 0 to 65535"),
     Units("Bytes")
    ]
    uint64 ReadAheadMultiplier;

     [Description("A segment is the amount of data, in kilobytes, that the controller writes on a single drive in a volume before writing data on the next drive.  Data blocks store 512 bytes of data and are the smallest units of storage.The size of a segment determines how many data blocks it contains."),
     Units("KB")
    ]
    uint64 SegmentSize;

     [Description("Vendor unique boolean: Set to true if there are any LUN mappings to this StorageVolume.")
    ]
    boolean isAssigned;

     [Description("Vendor unique string: The identifier of the volume group in which the volume resides.")
    ]
    string PoolId;

     [Description("Vendor unique string The RAID level for which this volume is configured.")
    ]
    string RaidLevel;

     [Description("Test variable to see if a vector of CIMInstances can be stored as a String[]")
    ]
    string CIMInstances[];

};

// LSISSI_DiskDrive

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Capabilities and managment of a DiskDrive, a subtype of MediaAccessDevice.")
    ]
class LSISSI_DiskDrive : CIM_DiskDrive {
    [Override("DeviceID"),
     Description("The variable length ASCII text string for the serial number of the controller. "),
     Key(true),
     MaxLen(64)
    ]
    string DeviceID;

     [Override("OperationalStatus"),
     Description("Indicates the current status(es) of the drive.  \n \"Non-RecoverableError, Invalid Drive Data\" indicates that no drive information (serial #, capacity, etc.) can be obtained.\"Non-RecoverableError\" indicates that the drive is in the failed state. \n \"In Service, Replaced\" indicates that the drive has been newly inserted into the storage array and is currently being prepared for use.  \n\"Stopped, Bypassed\" indicates that the drive is being bypassed.  \n \"Non-Recoverable Error, Unresponsive\" indicates that the drive is present but unresponsive.  \n "),
     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(" Sets the Drive status as Failed. This method wil return failed if the drive is in the primordial StoragePool or if the Drive is already failed. \n")
    ]
    uint16 setDriveToFailed();
     [Description(" Sets the Drive status to Optimal if the drive is already failed. This method will return failed if the drive is not already failed. \n")
    ]
    uint16 setDriveToOptimal();
};

// LSISSI_BackEndSCSIProtocolController

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("SCSIProtocolController is a type of ProtocolController, managing a SCSI interface.")
    ]
class LSISSI_BackEndSCSIProtocolController : CIM_SCSIProtocolController {
    [Override("ElementName"),
     MaxLen(64),
     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;

     [Description(" The Target Operating System property allows the provider to specify the  operating system environment. The value of this property does not  ensure binary executable.  Two other pieces of information are needed.   First, the version of the OS needs to be specified. using the OS  Version Check. The second piece of information is the architecture the  OS runs on. This information is capture with the ArchitectureCheck  class. The combination of these constructs allows the provider to  clearly identify the level of OS required for a particular software  element."),
     Values{"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000", "ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", "TPF", "Windows (R) Me", "Not Applicable"},
     ModelCorrespondence{"CIM_OperatingSystem.OSType"}
    ]
    uint16 TargetOperatingSystem;

     [Experimental(true),
     Description("System level port or bus identification number")
    ]
    uint64 PortNumber;

     [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", "48"},
     Values{"Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI", "Flexible Diskette", "1496", "SCSI Parallel Interface", "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", "I2C", "Power", "HIPPI", "MultiBus", "VME", "IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5", "IEEE 802.3 10BASE2", "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", "DSSI", "QIC2", "Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)", "FIR (fast infrared)", "SIR (serial infrared)", "IrBus", "Serial ATA"},
     MappingStrings{"MIF.DMTF|Bus Port|004.2", "MIF.DMTF|Disks|003.3"},
     ModelCorrespondence{"CIM_Controller.ProtocolDescription"}
    ]
    uint16 ProtocolSupported;

     [Deprecated{"No Value"},
     Description("An integer enumeration indicating whether or not the SCSIController provides redundancy or protection against device failures."),
     ValueMap{"1", "2", "3", "4", "5", "6"},
     Values{"Other", "Unknown", "Unprotected", "Protected", "Protected through SCC (SCSI-3 Controller Command)", "Protected through SCC-2 (SCSI-3 Controller Command)"},
     MappingStrings{"MIF.DMTF|Storage Controller|001.3"}
    ]
    uint16 ProtectionManagement;

     [Deprecated{"No Value"},
     Description("Maximum data width (in bits) supported by the SCSIController."),
     Units("Bits"),
     MappingStrings{"MIF.DMTF|Bus Port|004.7"}
    ]
    uint32 MaxDataWidth;

     [Deprecated{"No Value"},
     Description("Maximum transfer rate (in Bits per Second) supported by the SCSIController."),
     Units("Bits per Second"),
     MappingStrings{"MIF.DMTF|Bus Port|004.8"}
    ]
    uint64 MaxTransferRate;

     [Deprecated{"No Value"},
     Description("Number of SCSIController timeouts that have occurred since the TimeOfLastReset."),
     Counter(true)
    ]
    uint32 ControllerTimeouts;

     [Deprecated{"No Value"},
     Description("Signal capabilities that can be supported by the SCSIController. For example, the Controller may support \"Single Ended\" and \"Differential\". In this case, the values 3 and 4 would be written to the SignalCapabilities array."),
     ValueMap{"1", "2", "3", "4", "5", "6"},
     Values{"Other", "Unknown", "Single Ended", "Differential", "Low Voltage Differential", "Optical"},
     ModelCorrespondence{"CIM_SCSIInterface.SCSISignal"}
    ]
    uint16 SignalCapabilities[];

};

// LSISSI_SCSIProtocolController

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("SCSIProtocolController is a type of ProtocolController, managing a SCSI interface.")
    ]
class LSISSI_SCSIProtocolController : CIM_SCSIProtocolController {
    [Override("ElementName"),
     MaxLen(30),
     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;

     [Description("This tells whether or not the scsi protocol controller is the primordial protocol controller and therefore cannot be deleted.")
    ]
    boolean Primordial;

     [Description("This tells whether or not the scsi protocol controller can support collections due to it having been created outside of the SMI provider and therefore not conforming to SMI requirements.")
    ]
    boolean ProtocolControllerSupportsCollections;

};

// LSISSI_BackEndDeviceSCSIProtocolController

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("SCSIProtocolController is a type of ProtocolController, managing a SCSI interface.")
    ]
class LSISSI_BackEndDeviceSCSIProtocolController : CIM_SCSIProtocolController {
    [Override("ElementName"),
     MaxLen(64),
     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;

     [Description(" The Target Operating System property allows the provider to specify the  operating system environment. The value of this property does not  ensure binary executable.  Two other pieces of information are needed.   First, the version of the OS needs to be specified. using the OS  Version Check. The second piece of information is the architecture the  OS runs on. This information is capture with the ArchitectureCheck  class. The combination of these constructs allows the provider to  clearly identify the level of OS required for a particular software  element."),
     Values{"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000", "ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", "TPF", "Windows (R) Me", "Not Applicable"},
     ModelCorrespondence{"CIM_OperatingSystem.OSType"}
    ]
    uint16 TargetOperatingSystem;

     [Experimental(true),
     Description("System level port or bus identification number")
    ]
    uint64 PortNumber;

     [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", "48"},
     Values{"Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI", "Flexible Diskette", "1496", "SCSI Parallel Interface", "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", "I2C", "Power", "HIPPI", "MultiBus", "VME", "IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5", "IEEE 802.3 10BASE2", "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", "DSSI", "QIC2", "Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)", "FIR (fast infrared)", "SIR (serial infrared)", "IrBus", "Serial ATA"},
     MappingStrings{"MIF.DMTF|Bus Port|004.2", "MIF.DMTF|Disks|003.3"},
     ModelCorrespondence{"CIM_Controller.ProtocolDescription"}
    ]
    uint16 ProtocolSupported;

     [Deprecated{"No Value"},
     Description("An integer enumeration indicating whether or not the SCSIController provides redundancy or protection against device failures."),
     ValueMap{"1", "2", "3", "4", "5", "6"},
     Values{"Other", "Unknown", "Unprotected", "Protected", "Protected through SCC (SCSI-3 Controller Command)", "Protected through SCC-2 (SCSI-3 Controller Command)"},
     MappingStrings{"MIF.DMTF|Storage Controller|001.3"}
    ]
    uint16 ProtectionManagement;

     [Deprecated{"No Value"},
     Description("Maximum data width (in bits) supported by the SCSIController."),
     Units("Bits"),
     MappingStrings{"MIF.DMTF|Bus Port|004.7"}
    ]
    uint32 MaxDataWidth;

     [Deprecated{"No Value"},
     Description("Maximum transfer rate (in Bits per Second) supported by the SCSIController."),
     Units("Bits per Second"),
     MappingStrings{"MIF.DMTF|Bus Port|004.8"}
    ]
    uint64 MaxTransferRate;

     [Deprecated{"No Value"},
     Description("Number of SCSIController timeouts that have occurred since the TimeOfLastReset."),
     Counter(true)
    ]
    uint32 ControllerTimeouts;

     [Deprecated{"No Value"},
     Description("Signal capabilities that can be supported by the SCSIController. For example, the Controller may support \"Single Ended\" and \"Differential\". In this case, the values 3 and 4 would be written to the SignalCapabilities array."),
     ValueMap{"1", "2", "3", "4", "5", "6"},
     Values{"Other", "Unknown", "Single Ended", "Differential", "Low Voltage Differential", "Optical"},
     ModelCorrespondence{"CIM_SCSIInterface.SCSISignal"}
    ]
    uint16 SignalCapabilities[];

};

// CIM_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\nNote 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\nThe 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(true), IN(true), Description("The Subject parameter is a reference to a ManagedElement instance. This parameter MUST be supplied.")] CIM_ManagedElement REF Subject, [IN(true), 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(true), Description("MUST be NULL unless the Privilege is NULL on input. This parameter specifies the activities to be granted or denied."), ValueMap{"1", "2", "3", "4", "5", "6", "7", "..", "16000..65535"}, Values{"Other", "Create", "Delete", "Detect", "Read", "Write", "Execute", "DMTF Reserved", "Vendor Reserved"}, ArrayType("Indexed"), ModelCorrespondence{"CIM_AuthorizedPrivilege.Activities", "CIM_PrivilegeManagementService.AssignAccess.Privilege"}] uint16 Activities[], [IN(true), 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(true), Description("MUST be NULL unless Privilege is NULL on input. This parameter defines the qualifier formats for the corresponding ActivityQualifiers."), 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"}, ArrayType("Indexed"), ModelCorrespondence{"CIM_AuthorizedPrivilege.QualifierFormats", "CIM_PrivilegeManagementService.AssignAccess.Privilege"}] uint16 QualifierFormats[], [Required(true), IN(true), Description("The Target parameter is a reference to an instance of ManagedElement. This parameter MUST be supplied.")] CIM_ManagedElement REF Target, [IN(true), OUT(true), 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(true), 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(true), Description("A reference to the AuthorizedPrivilege to be revoked.")] CIM_AuthorizedPrivilege REF Privilege, [IN(true), 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);
};

// CIM_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(true), Description("The ElementName of the new StorageHardwareID instance.")] string ElementName, [IN(true), Description("StorageID is the value used by the SecurityService to represent Identity - in this case, a hardware worldwide unique name.")] string StorageID, [IN(true), Description("The type of the StorageID property."), ValueMap{"1", "2", "3", "4"}, Values{"Other", "PortWWN", "NodeWWN", "Hostname"}] uint16 IDType, [IN(true), Description("The type of the storage ID, when IDType is \"Other\".")] string OtherIDType, [IN(true), 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(true), Description("REF to the new StorageHardwareID 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(true), Description("The storage hardware ID to be deleted.")] CIM_StorageHardwareID REF HardwareID);
     [Description("This method creates a CIM_GatewayPathID and the association CIM_ConcreteDependency between this service and the new GatewayPathID."),
     ValueMap{"0", "1", "2", "3", "4", "5", "6..0xFFF", "0x1000", "0x1001", "0x1003", "0x1004", "0x1005..0x7FFF", "0x8000.."},
     Values{"Success", "Not Supported", "Unspecified Error", "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved", "ID already created", "Hardware implementation does not support specified IDType", "GatewayPathID already created", "Hardware implementation does not support specified GatewayIDType", "Method Reserved", "Vendor Specific"}
    ]
    uint32 CreateGatewayPathID([IN(true), Description("The ElementName of the new StorageHardwareID instance.")] string ElementName, [IN(true), Description("StorageID is the value used by the SecurityService to represent Identity - in this case, a hardware worldwide unique name.")] string StorageID, [IN(true), Description("The type of the ID property."), ValueMap{"1", "2", "3", "4"}, Values{"Other", "PortWWN", "NodeWWN", "Hostname"}] uint16 IDType, [IN(true), Description("The type of the storage ID, when IDType is \"Other\".")] string OtherIDType, [IN(true), Description("GatewayID is the value used by the SecurityService to represent identity of a Gateway element.")] string GatewayID, [IN(true), Description("The type of the GatewayID property."), ValueMap{"1", "2", "3", "4"}, Values{"Other", "PortWWN", "NodeWWN", "Hostname"}] uint16 GatewayIDType, [IN(true), Description("The type of the storage ID, when GatewayIDType is \"Other\".")] string OtherGatewayIDType, [IN(false), OUT(true), Description("REF to the new GatewayPathID instance.")] CIM_GatewayPathID REF NewGatewayPathID);
     [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(true), Description("The ElementName to be assigned to the created collection.")] string ElementName, [IN(true), Description("Array of strings containing representations of references to StorageHardwareID instances that will become members of the new collection.")] string HardwareIDs[], [IN(false), OUT(true), 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(true), Description("Array of strings containing representations of references to StorageHardwareID instances that will become members of the collection.")] string HardwareIDs[], [IN(true), Description("The Collection which groups the StorageHardwareIDs.")] CIM_SystemSpecificCollection REF Collection);
};

// LSISSI_FCPort

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Capabilities and management of a Fibre Channel Port Device.")
    ]
class LSISSI_FCPort : CIM_FCPort {
};

// LSISSI_BackEndFCPort

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Capabilities and management of a Fibre Channel Port Device.")
    ]
class LSISSI_BackEndFCPort : CIM_FCPort {
};

// LSISSI_BackEndDeviceFCPort

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("Capabilities and management of a Fibre Channel Port Device.")
    ]
class LSISSI_BackEndDeviceFCPort : CIM_FCPort {
};

// LSISSI_LunMaskPrivilegeService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_LunMaskPrivilegeService : CIM_PrivilegeManagementService {
};

// LSISSI_HostHardwareIDManagementService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("StorageHardwareIDManagementService provides methods for manipulating instances of StorageHardwareIDs and manipulating the trust of these IDs in the underlying storage system.")
    ]
class LSISSI_HostHardwareIDManagementService : CIM_StorageHardwareIDManagementService {
};

// LSISSI_SharedSecretService

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("CIM_SharedSecretService is a service which ascertains whether messages received are from the Principal with whom a secret is shared. Examples include a login service that proves identity on the basis of knowledge of the shared secret, or a transport integrity service (like Kerberos provides) that includes a message authenticity code that proves each message in the messsage stream came from someone who knows the shared secret session key.")
    ]
class LSISSI_SharedSecretService : CIM_SharedSecretService {
};
