
#pragma namespace ("/interop")

#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_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_IndicationFilter

    [Version("2.6.0"),
     Description("CIM_IndicationFilter defines the criteria for generating an Indication and what data should be returned in the Indication. It is derived from CIM_ManagedElement to allow modeling the dependency of the filter on a specific service.")
    ]
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"),
     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"),
     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;

};

// WBEMServices_Classpath

    [Provider("internal:java"),
     Description("Each instance becomes part of the classpath used by WBEMServices CIMOM"),
     Version("1.2.0")
    ]
class WBEMServices_Classpath {
    [key(true),
     Description("A URL pointing to a jar file or directory to place on the classpath. If this specifies a file, you can use the special identifier {0} to indicate that the BASEDIR should be used.  The BASEDIR is the base install location.  For example, file://{0}/usr/sadm/lib/wbem/myjar.jar")
    ]
    string pathurl;

};

// 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_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_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_ServiceAvailableToElement

    [Association(true),
     Version("2.7.0"),
     Description("CIM_ServiceAvailableToElement conveys the semantics of a Service being available for the \'use\' of a ManagedElement. An example is that a Processor and an enclosure (a PhysicalElement) may use AlertOnLAN Services to signal an incomplete or erroneous boot. In reality, AlertOnLAN is simply a HostedService on a computer system that is generally \'available for use\', and not a dependency of the processor or enclosure. To describe that use of this service is restricted or has limited availability/applicability, then the CIM_ServiceAvailableToElement association would be instantiated between the Service and specific CIM_Processors and CIM_Chassis .")
    ]
class CIM_ServiceAvailableToElement {
    [Key(true),
     Description("The Service that is available.")
    ]
    CIM_Service REF ServiceProvided;

     [Key(true),
     Description("The ManagedElement that may use the Service.")
    ]
    CIM_ManagedElement REF UserOfService;

};

// 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_ElementConformsToProfile

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

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

};

// WBEMServices_ObjectManager

    [Description("This class represents the open WBEM Services object manager."),
     Provider("internal:WBEMServices_ObjectManager"),
     Version("1.2.0")
    ]
class WBEMServices_ObjectManager : CIM_ObjectManager {
    [Description("Version of this object manager.")
    ]
    string Version;

    [Description("This method forces the object manager to process MOFs that have been set up in its MOF registration directory")
    ]
    sint8 registerMOF();
};

// WBEMServices_ObjectManagerProtocolAdapter

    [Description("This is the base class for protocol adapters. A protocol adapter is a service through which the CIMOM performs protocol mappings while communicating with external entities."),
     Version("1.2.0")
    ]
class WBEMServices_ObjectManagerProtocolAdapter : CIM_Service {
    [Description("Class path for all the supporting classes that this protocol adapter needs.")
    ]
    string classPath[];

     [Description("This represents the name of the class that provides the implementation for the particular protocol instance")
    ]
    string ImplClass;

};

// WBEMServices_ProtocolAdapterForManager

    [Association(true),
     Abstract(true),
     Version("1.2.0"),
     Description("This association is the base class for associations linking the object manager to its protocol adapter")
    ]
class WBEMServices_ProtocolAdapterForManager : CIM_Dependency {
    [Override("Antecedent"),
     Min(1),
     Max(1),
     Description("The specific Object Manager whose protocol adapter is described."),
     Key(true)
    ]
    WBEMServices_ObjectManager REF Antecedent;

     [Override("Dependent"),
     Min(1),
     Description("The protocol adapter for the Object Manager."),
     Key(true)
    ]
    WBEMServices_ObjectManagerProtocolAdapter REF Dependent;

};

// CIM_SoftwareIdentity

    [Version("2.8.1000"),
     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", "12", "..", "0x8000..0xFFFF"},
     Values{"Unknown", "Other", "Driver", "Configuration Software", "Application Software", "Instrumentation", "Firmware/BIOS", "Diagnostic Software", "Operating System", "Middleware", "Firmware", "BIOS/FCode", "Support/Service Pack", "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;

     [Experimental(true),
     Description("An application specific invariant identifier that will be consistent between versions of a SoftwareIdentity. It will also be consistent across more major changes to the Software Identity naming structure. The purpose of the parameter is to allows Software Identities to be selected by a client that are compatible with a specific SoftwareInstallationService. A client uses this parameter to select candidate Software Identities by comparing TargetType with the contents of the SupportedTargetTypes parameter in SoftwareInstallationServiceCapabilities."),
     ModelCorrespondence{"CIM_SoftwareInstallationServiceCapabilities.SupportedTargetTypes"}
    ]
    string TargetType;

     [Experimental(true),
     Description("The date the software was released.")
    ]
    datetime ReleaseDate;

};

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

};

// LSISSI_ServiceAvailableToElement

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("CIM_ServiceAvailableToElement conveys the semantics of a Service being available for the \'use\' of a ManagedElement. An example is that a Processor and an enclosure (a PhysicalElement) may use AlertOnLAN Services to signal an incomplete or erroneous boot. In reality, AlertOnLAN is simply a HostedService on a computer system that is generally \'available for use\', and not a dependency of the processor or enclosure. To describe that use of this service is restricted or has limited availability/applicability, then the CIM_ServiceAvailableToElement association would be instantiated between the Service and specific CIM_Processors and CIM_Chassis ."),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ServiceAvailableToElement : CIM_ServiceAvailableToElement {
};

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

// LSISSI_ObjectManagerElementConformsToProfile

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

// WBEMServices_ObjectManagerClientProtocolAdapter

    [Description("This class is the base class for all adapters that enable the Object manager to communciate with clients which perform CIM operations over different protocols"),
     Version("1.2.0"),
     Provider("internal:WBEMServices_ObjectManagerClientProtocolAdapter")
    ]
class WBEMServices_ObjectManagerClientProtocolAdapter : WBEMServices_ObjectManagerProtocolAdapter {
};

// WBEMServices_ClientProtocolAdapterForManager

    [Association(true),
     Description("This class represents the association between the the object manager and the client protocol adapter."),
     Version("1.2.0"),
     Provider("internal:WBEMServices_ClientProtocolAdapterForManager")
    ]
class WBEMServices_ClientProtocolAdapterForManager : WBEMServices_ProtocolAdapterForManager {
    [Min(1),
     Description("The client protocol adapter for the Object Manager."),
     Override("Dependent"),
     Key(true)
    ]
    WBEMServices_ObjectManagerClientProtocolAdapter REF Dependent;

};

// WBEMServices_ObjectManagerProviderProtocolAdapter

    [Description("This class is the base class for all adapters that enable the Object manager to communciate with providers using different protocols."),
     Version("1.2.0"),
     Provider("internal:WBEMServices_ObjectManagerProviderProtocolAdapter")
    ]
class WBEMServices_ObjectManagerProviderProtocolAdapter : WBEMServices_ObjectManagerProtocolAdapter {
    [Description("The protocolType is the keyword used in Provider qualifiersto denote the provider protocol to be used while contacting the specificprovider")
    ]
    string ProtocolType;

};

// WBEMServices_ProviderProtocolAdapterForManager

    [Association(true),
     Description("This class represents the association between the the object manager and the provider protocol adapter."),
     Version("1.2.0"),
     Provider("internal:WBEMServices_ProviderProtocolAdapterForManager")
    ]
class WBEMServices_ProviderProtocolAdapterForManager : WBEMServices_ProtocolAdapterForManager {
    [Min(1),
     Description("The provider protocol adapter for the Object Manager."),
     Override("Dependent"),
     Key(true)
    ]
    WBEMServices_ObjectManagerProviderProtocolAdapter REF Dependent;

};

// LSISSI_ServerElementSoftwareIdentity

    [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_ServerElementSoftwareIdentity : CIM_ElementSoftwareIdentity {
};

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

};

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

};

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

};

// LSISSI_ServerRegisteredProfile

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     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 LSISSI_ServerRegisteredProfile : CIM_RegisteredProfile {
    [Override("InstanceID"),
     MaxLen(64),
     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\'."),
     Key(true)
    ]
    string InstanceID;

};

// LSISSI_RegisteredProfile

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

// Solaris_JAVAXRMIDelivery

    [Provider("internal:solaris_javaxrmidelivery"),
     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 Solaris_JAVAXRMIDelivery : CIM_ListenerDestination {
};

// CIM_ListenerDestinationCIMXML

    [Version("2.8.0"),
     Description("CIM_ListenerDestinationCIMXML describes the destination for CIM Export Messages to be delivered via CIM-XML.")
    ]
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_Namespace

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

// 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_ServerHostedAccessPoint

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

// LSISSI_NamespaceInManager

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("NamespaceInManager is an association describing the Namespaces hosted by a CIM ObjectManager.")
    ]
class LSISSI_NamespaceInManager : CIM_NamespaceInManager {
};

// LSISSI_ObjectManagerHostedService

    [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_ObjectManagerHostedService : CIM_HostedService {
};

// LSISSI_SubprofileRequiresProfile

    [Association(true),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("A subprofile requires another RegisteredProfile for context. This association mandates the scoping relationship between a subprofile and its scoping profile.")
    ]
class LSISSI_SubprofileRequiresProfile : CIM_SubProfileRequiresProfile {
};

// LSISSI_CommMechanismForManager

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

// LSISSI_RegisteredSubProfile

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

// LSISSI_CimomSharedSecret

    [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_CimomSharedSecret : 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_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_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_ServerProviderSoftwareIdentity

    [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_ServerProviderSoftwareIdentity : 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);
};

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

// LSISSI_StorageManagementSystem

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

// 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_CIMXMLCommunicationMechanism

    [Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     Description("This class specializes ObjectManagerCommunicationMechanism, adding properties specific to the CIM-XML protocol (XML encoding and CIM Operations).")
    ]
class LSISSI_CIMXMLCommunicationMechanism : CIM_CIMXMLCommunicationMechanism {
};

// LSISSI_ObjectManagerClientProtocolAdapter

    [Description("This class in the Provider enables the Object manager to communciate with clients which perform CIM operations over different protocols with the userspecified port number"),
     Version("1.2.0"),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_ObjectManagerClientProtocolAdapter : WBEMServices_ObjectManagerClientProtocolAdapter {
    [Description("This is the port number on which the registry listens.")
    ]
    uint32 PortNumber;

};

// LSISSI_CIMXMLObjectManagerClientProtocolAdapter

    [Description("This class represents the cim-xml protocol adapter which enables the object manager to communicate with clients using CIM operations over HTTPS"),
     Version("1.2.0"),
     Provider("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider"),
     ProviderName("java:org.eclipse.aperi.simulator.cimom.sunwbem.provider.Provider")
    ]
class LSISSI_CIMXMLObjectManagerClientProtocolAdapter : WBEMServices_ObjectManagerClientProtocolAdapter {
    [Description("This is the port number on which the HTTP server listens. The default value is 5988 for HTTP and 5989 for HTTPS")
    ]
    uint32 PortNumber;

     [Description("This determines whether we should use SSL to encrypt the data. The default value is false")
    ]
    boolean SSLEnable;

     [Description("This determines whether we should use client authentication with SSL. This value is ignored if SSLEnable is false.The default value is false")
    ]
    boolean SSLAuthentication;

     [Description("This defines the location of the keystore file. This value is ignored if SSLEnable is false. The default value is \'keystore_file\'")
    ]
    string SSLKeyStoreFile;

     [Description("This defines the password to the keystore file. This value is ignored if SSLEnable is false.The default value is \'password\'")
    ]
    string SSLKeyStorePass;

     [Description("This defines the password to the keyEntry in the keystore file. This value is ignored if SSLEnable is false.The default value is \'password\'")
    ]
    string SSLKeyStoreKeyPass;

     [Description("This defines the location of the truststore file. This value is ignored if SSLEnable is false or SSLAuthentication is false. The default value is \'truststore_file\'")
    ]
    string SSLTrustStoreFile;

     [Description("This defines the password to the truststore file. This value is ignored if SSLEnable is false or SSLAuthentication is false. The default value is \'password\'")
    ]
    string SSLTrustStorePass;

};

// LSISSI_ObjectManager

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

// LSISSI_CimomSharedSecretService

    [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_CimomSharedSecretService : CIM_SharedSecretService {
};
