// Copyright (c) 2012 DMTF.  All rights reserved.
   [Version ( "2.36.0" ), 
    UMLPackagePath ( "CIM::Core::CoreElements" ), 
    Description ( 
       "This class defines a view class for a physical computer system." )]
class CIM_PhysicalComputerSystemView : CIM_View {

      [Key, Override ( "InstanceID" ), 
       Description ( 
          "InstanceID is the property that may be used to opaquely "
          "and uniquely identify an instance of this class within "
          "the scope of the instantiating Namespace." )]
   string InstanceID;

      [Description ( 
          "This property corresponds to the EnabledState property "
          "of the logical computer system represented by "
          "CIM_ComputerSystem. See "
          "CIM_EnabledLogicalElement.EnabledState for details on "
          "EnabledState." ), 
       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_ComputerSystem.EnabledState" }]
   uint16 EnabledState;

      [Description ( 
          "This property corresponds to the RequestedState property "
          "of the logical computer system represented by "
          "CIM_ComputerSystem. See "
          "CIM_EnabledLogicalElement.RequestedState for details on "
          "RequestedState." ), 
       ValueMap { "0", "2", "3", "4", "5", "6", "7", "8", "9", "10", 
          "11", "12", "..", "32768..65535" }, 
       Values { "Unknown", "Enabled", "Disabled", "Shut Down", 
          "No Change", "Offline", "Test", "Deferred", "Quiesce", 
          "Reboot", "Reset", "Not Applicable", "DMTF Reserved", 
          "Vendor Reserved" }, 
       ModelCorrespondence { "CIM_ComputerSystem.RequestedState" }]
   uint16 RequestedState;

      [Description ( 
          "This property corresponds to the OperationalStatus "
          "property of the logical computer system represented by "
          "CIM_ComputerSystem. See "
          "CIM_ManagedSystemElement.OperationalStatus Description "
          "for details." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
          "10", "11", "12", "13", "14", "15", "16", "17", "18", 
          "19", "..", "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", 
          "Relocating", "DMTF Reserved", "Vendor Reserved" }, 
       ModelCorrespondence { "CIM_ComputerSystem.OperationalStatus" }]
   uint16 OperationalStatus[];

      [Description ( 
          "This property corresponds to the HealthState property of "
          "the logical computer system represented by "
          "CIM_ComputerSystem. See "
          "CIM_ManagedSystemElement.HealthState for details." ), 
       ValueMap { "0", "5", "10", "15", "20", "25", "30", "..", 
          "32768..65535" }, 
       Values { "Unknown", "OK", "Degraded/Warning", 
          "Minor failure", "Major failure", "Critical failure", 
          "Non-recoverable error", "DMTF Reserved", "Vendor Specific" }, 
       ModelCorrespondence { "CIM_ComputerSystem.HealthState" }]
   uint16 HealthState;

      [Description ( 
          "This property indicates the availability of the FRU "
          "Information on this physical computer system. See "
          "CIM_PhysicalAssetCapabilities.FRUInfoSupported for "
          "details." ), 
       ModelCorrespondence { 
          "CIM_PhysicalAssetCapabilities.FRUInfoSupported" }]
   boolean FRUInfoSupported;

      [Description ( 
          "This property corresponds to CIM_PhysicalFrame.Tag. See "
          "CIM_PhysicalFrame.Tag for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.Tag" }]
   string Tag;

      [Description ( 
          "This property corresponds to "
          "CIM_PhysicalFrame.Manufacturer. See "
          "CIM_PhysicalFrame.Manufacturer for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.Manufacturer" }]
   string Manufacturer;

      [Description ( 
          "This property corresponds to CIM_PhysicalFrame.Model. "
          "See CIM_PhysicalFrame.Model for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.Model" }]
   string Model;

      [Description ( 
          "This property corresponds to CIM_PhysicalFrame.SKU. See "
          "CIM_PhysicalFrame.SKU for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.SKU" }]
   string SKU;

      [Description ( 
          "This property corresponds to "
          "CIM_PhysicalFrame.SerialNumber. See "
          "CIM_PhysicalFrame.SerialNumber for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.SerialNumber" }]
   string SerialNumber;

      [Description ( 
          "This property corresponds to CIM_PhysicalFrame.Version. "
          "See CIM_PhysicalFrame.Version for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.Version" }]
   string Version;

      [Description ( 
          "This property corresponds to "
          "CIM_PhysicalFrame.PartNumber. See "
          "CIM_PhysicalFrame.PartNumber for details." ), 
       ModelCorrespondence { "CIM_PhysicalFrame.PartNumber" }]
   string PartNumber;

      [Description ( 
          "This property corresponds to "
          "PowerUtilizationModesSupported property of "
          "CIM_PowerUtilizationManagementCapabilities. See "
          "CIM_PowerUtilizationManagementCapabilities.PowerUtilizationModesSupported "
          "for details." ), 
       ValueMap { "3", "4", "..", "32768..65535" }, 
       Values { "Dynamic", "Static", "DMTF Reserved", 
          "Vendor Reserved" }, 
       ModelCorrespondence { 
          "CIM_PowerUtilizationManagementCapabilities.PowerUtilizationModesSupported" }]
   uint16 PowerUtilizationModesSupported[];

      [Description ( 
          "This property corresponds to the PowerUtilizationMode of "
          "the CIM_PowerUtilizationManagementService. See "
          "CIM_PowerUtilizationManagementService.PowerUtilizationMode "
          "for details." ), 
       ValueMap { "2", "3", "4", "..", "32768..65535" }, 
       Values { "None", "Dynamic", "Static", "DMTF Reserved", 
          "Vendor Reserved" }, 
       ModelCorrespondence { 
          "CIM_PowerUtilizationManagementService.PowerUtilizationMode" }]
   uint16 PowerUtilizationMode;

      [Description ( 
          "This property corresponds to "
          "CIM_PowerAllocationSettingData.Limit. See "
          "CIM_PowerAllocationSettingData.Limit for details." ), 
       ModelCorrespondence { "CIM_PowerAllocationSettingData.Limit" }, 
       PUnit ( "watt * 10^-3" )]
   uint64 PowerAllocationLimit;

      [Description ( 
          "User-friendly names of the numeric sensors on the "
          "computer system. See CIM_NumericSensor.ElementName for "
          "details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.ElementName" }]
   string NumericSensorElementName[];

      [Description ( 
          "States of numeric sensors. See "
          "CIM_NumericSensor.EnabledState for details." ), 
       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" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.EnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName" }]
   uint16 NumericSensorEnabledState[];

      [Description ( 
          "Health states of numeric sensors. See "
          "CIM_NumericSensor.HealthState for details." ), 
       ValueMap { "0", "5", "10", "15", "20", "25", "30", "..", 
          "32768..65535" }, 
       Values { "Unknown", "OK", "Degraded/Warning", 
          "Minor failure", "Major failure", "Critical failure", 
          "Non-recoverable error", "DMTF Reserved", "Vendor Specific" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.HealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState" }]
   uint16 NumericSensorHealthState[];

      [Description ( 
          "Current states of numeric sensors. See "
          "CIM_NumericSensor.CurrentState for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.CurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState" }]
   string NumericSensorCurrentState[];

      [Description ( 
          "Primary statuses of numeric sensors. See "
          "CIM_NumericSensor.PrimaryStatus for details." ), 
       ValueMap { "0", "1", "2", "3", "..", "0x8000.." }, 
       Values { "Unknown", "OK", "Degraded", "Error", 
          "DMTF Reserved", "Vendor Reserved" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.PrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState" }]
   uint16 NumericSensorPrimaryStatus[];

      [Description ( 
          "Base units of the values returned by the numeric "
          "sensors. See CIM_NumericSensor.BaseUnits for details." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
          "10", "11", "12", "13", "14", "15", "16", "17", "18", 
          "19", "20", "21", "22", "23", "24", "25", "26", "27", 
          "28", "29", "30", "31", "32", "33", "34", "35", "36", 
          "37", "38", "39", "40", "41", "42", "43", "44", "45", 
          "46", "47", "48", "49", "50", "51", "52", "53", "54", 
          "55", "56", "57", "58", "59", "60", "61", "62", "63", 
          "64", "65", "66" }, 
       Values { "Unknown", "Other", "Degrees C", "Degrees F", 
          "Degrees K", "Volts", "Amps", "Watts", "Joules", 
          "Coulombs", "VA", "Nits", "Lumens", "Lux", "Candelas", 
          "kPa", "PSI", "Newtons", "CFM", "RPM", "Hertz", "Seconds", 
          "Minutes", "Hours", "Days", "Weeks", "Mils", "Inches", 
          "Feet", "Cubic Inches", "Cubic Feet", "Meters", 
          "Cubic Centimeters", "Cubic Meters", "Liters", 
          "Fluid Ounces", "Radians", "Steradians", "Revolutions", 
          "Cycles", "Gravities", "Ounces", "Pounds", "Foot-Pounds", 
          "Ounce-Inches", "Gauss", "Gilberts", "Henries", "Farads", 
          "Ohms", "Siemens", "Moles", "Becquerels", 
          "PPM (parts/million)", "Decibels", "DbA", "DbC", "Grays", 
          "Sieverts", "Color Temperature Degrees K", "Bits", 
          "Bytes", "Words (data)", "DoubleWords", "QuadWords", 
          "Percentage", "Pascals" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.BaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus" }]
   uint16 NumericSensorBaseUnits[];

      [Description ( 
          "Unit modifiers for the values returned by the numeric "
          "sensors. See CIM_NumericSensor.UnitModifier description "
          "for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.UnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits" }]
   sint32 NumericSensorUnitModifier[];

      [Description ( "See CIM_NumericSensor.RateUnits for details." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" }, 
       Values { "None", "Per MicroSecond", "Per MilliSecond", 
          "Per Second", "Per Minute", "Per Hour", "Per Day", 
          "Per Week", "Per Month", "Per Year" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.RateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier" }]
   uint16 NumericSensorRateUnits[];

      [Description ( 
          "See CIM_NumericSensor.CurrentReading for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.CurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits" }]
   sint32 NumericSensorCurrentReading[];

      [Description ( "See CIM_NumericSensor.SensorType for details." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
          "10", "11", "12", "13", "14", "15", "..", "32768..65535" }, 
       Values { "Unknown", "Other", "Temperature", "Voltage", 
          "Current", "Tachometer", "Counter", "Switch", "Lock", 
          "Humidity", "Smoke Detection", "Presence", "Air Flow", 
          "Power Consumption", "Power Production", "Pressure", 
          "DMTF Reserved", "Vendor Reserved" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.SensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading" }]
   uint16 NumericSensorSensorType[];

      [Description ( 
          "See CIM_NumericSensor.OtherSensorTypeDescription for details."
           ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.OtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType" }]
   string NumericSensorOtherSensorTypeDescription[];

      [Description ( 
          "See CIM_NumericSensor.UpperThresholdNonCritical for details."
           ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.UpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription" }]
   sint32 NumericSensorUpperThresholdNonCritical[];

      [Description ( 
          "See CIM_NumericSensor.UpperThresholdCritical description "
          "for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.UpperThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical" }]
   sint32 NumericSensorUpperThresholdCritical[];

      [Description ( 
          "See CIM_NumericSensor.UpperThresholdFatal for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.UpperThresholdFatal", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdCritical" }]
   sint32 NumericSensorUpperThresholdFatal[];

      [Description ( 
          "This property represents the identifiers for the "
          "underlying logs on this physical computer system. See "
          "CIM_RecordLog.InstanceID for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RecordLog.InstanceID" }]
   string LogInstanceID[];

      [Description ( 
          "See CIM_RecordLog.MaxNumberOfRecords for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RecordLog.MaxNumberOfRecords", 
          "CIM_PhysicalComputerSystemView.LogInstanceID" }]
   uint64 LogMaxNumberOfRecords[];

      [Description ( 
          "See CIM_RecordLog.CurrentNumberOfRecords for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RecordLog.CurrentNumberOfRecords", 
          "CIM_PhysicalComputerSystemView.LogInstanceID", 
          "CIM_PhysicalComputerSystemView.LogMaxNumberOfRecords" }]
   uint64 LogCurrentNumberOfRecords[];

      [Description ( 
          "See CIM_RecordLog.OverWritePolicy for details." ), 
       ValueMap { "0", "2", "7", "..", "32768..65535" }, 
       Values { "Unknown", "Wraps When Full", "Never Overwrites", 
          "DMTF Reserved", "Vendor Reserved" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RecordLog.OverwritePolicy", 
          "CIM_PhysicalComputerSystemView.LogInstanceID", 
          "CIM_PhysicalComputerSystemView.LogMaxNumberOfRecords", 
          "CIM_PhysicalComputerSystemView.LogCurrentNumberOfRecords" }]
   uint16 LogOverWritePolicy[];

      [Description ( "See CIM_RecordLog.LogState for details." ), 
       ValueMap { "0", "2", "3", "4", "..", "32768..65535" }, 
       Values { "Unknown", "Normal", "Erasing", "Not Applicable", 
          "DMTF Reserved", "Vendor Reserved" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RecordLog.LogState", 
          "CIM_PhysicalComputerSystemView.LogInstanceID", 
          "CIM_PhysicalComputerSystemView.LogMaxNumberOfRecords", 
          "CIM_PhysicalComputerSystemView.LogCurrentNumberOfRecords", 
          "CIM_PhysicalComputerSystemView.LogOverwritePolicy" }]
   uint16 LogState[];

      [Description ( 
          "Strings identifying the boot sources on this physical "
          "computer system. See "
          "CIM_BootSourceSetting.StructuredBootString description "
          "for details." ), 
       ModelCorrespondence { 
          "CIM_BootSourceSetting.StructuredBootString" }]
   string StructuredBootString[];

      [Description ( 
          "An array of elements identifying the boot order of the "
          "persistent boot configuration that shall be used during "
          "the next boot of the computer system, unless the "
          "OneTimeBootSource for the next boot is specified. The "
          "value of each element in this array is an index "
          "referencing an element in the array of "
          "StructuredBootString." ), 
       ArrayType ( "Ordered" )]
   uint8 PersistentBootConfigOrder[];

      [Description ( 
          "This property identifies the boot source that is used "
          "for the next one-time boot. The value of this property "
          "is an index referencing an element in the array of "
          "StructuredBootString." )]
   uint8 OneTimeBootSource;

      [Description ( 
          "This property identifies the number of processors on "
          "this physical computer system." )]
   uint16 NumberOfProcessors;

      [Description ( 
          "See CIM_ProcessorCapabilities.NumberOfProcessorCores for details."
           ), 
       ModelCorrespondence { 
          "CIM_ProcessorCapabilities.NumberOfProcessorCores" }]
   uint16 NumberOfProcessorCores;

      [Description ( 
          "See CIM_ProcessorCapabilities.NumberOfProcessorThreads "
          "for details." ), 
       ModelCorrespondence { 
          "CIM_ProcessorCapabilities.NumberOfHardwareThreads" }]
   uint16 NumberOfProcessorThreads;

      [Description ( "See CIM_Processor.Family for details." ), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", 
          // 11                   
          "11", "12", "13", "14", 
          "15", "16", "17", "18", "19", "20", "21", 
          // 24                   
          "24", "25", "26", "27", 
          "28", "29", "30", "31", "32", "33", "34", "35", "36", 
          "37", "38", "39", "40", "41", "42", "43", 
          // 48                   
          "48", "49", "50", "51", 
          "52", "53", "54", "55", "56", "57", "58", "59", "60", 
          "61", "62", "63", // 64                   
          "64", 
          "65", "66", "67", "68", "69", "70", "71", "72", "73", 
          "74", "75", "76", "77", "78", "79", 
          // 80                   
          "80", "81", "82", "83", 
          "84", "85", "86", "87", "88", 
          // 96                      
          "96", "97", "98", 
          "99", "100", "101", "102", "103", "104", 
          // 112                   
          "112", "120", "121", 
          "122", "128", "130", "131", "132", "133", "134", 
          // 135
          "135", "136", "137", "138", "139", "140", 
          "141", "142", "143", 
          // 144                      
          "144", "145", 
          "146", "147", "148", "149", "150", 
          // 160                      
          "160", "161", 
          "162", "163", "164", "165", "166", "167", "168", "169", 
          // 170
          "170", "171", "172", "173", "174", "175", 
          "176", "177", "178", "179", // 180
          "180", "181", 
          "182", "183", "184", "185", "186", "187", "188", "189", 
          // 190                   
          "190", "191", "192", 
          "193", "194", "195", "196", "197", "198", "199", 
          // 200                   
          "200", "201", "202", 
          "203", "204", "205", "206", // 210
          "210", "211", 
          "212", "213", "214", "215", "216", "217", "218", "219", 
          // 220
          "221", "222", "223", "224", "228", "229", 
          // 230 
          "230", "231", "232", "233", "234", 
          "235", "236", "237", "238", "239", 
          // 250                 
          "250", "251", "254", 
          "255", "260", "261", "280", "281", 
          // 300                 
          "300", "301", "302", 
          "320", "350", "500", 
          // 65534                 
          "65534", "65535" }, 
       Values { "Other", "Unknown", "8086", "80286", "80386", 
          "80486", "8087", "80287", "80387", "80487", 
          // 11                     
          "Pentium(R) brand", 
          "Pentium(R) Pro", "Pentium(R) II", 
          "Pentium(R) processor with MMX(TM) technology", 
          "Celeron(TM)", "Pentium(R) II Xeon(TM)", "Pentium(R) III", 
          "M1 Family", "M2 Family", 
          "Intel(R) Celeron(R) M processor", 
          "Intel(R) Pentium(R) 4 HT processor", 
          // 24                    
          "K5 Family", 
          "K6 Family", "K6-2", "K6-3", 
          "AMD Athlon(TM) Processor Family", 
          "AMD(R) Duron(TM) Processor", "AMD29000 Family", 
          // 31                    
          "K6-2+", 
          "Power PC Family", "Power PC 601", "Power PC 603", 
          "Power PC 603+", "Power PC 604", "Power PC 620", 
          "Power PC X704", "Power PC 750", 
          "Intel(R) Core(TM) Duo processor", 
          "Intel(R) Core(TM) Duo mobile processor", 
          "Intel(R) Core(TM) Solo mobile processor", 
          "Intel(R) Atom(TM) processor", 
          // 48                     
          "Alpha Family", 
          "Alpha 21064", "Alpha 21066", "Alpha 21164", 
          "Alpha 21164PC", "Alpha 21164a", "Alpha 21264", 
          "Alpha 21364", 
          // 56
          "AMD Turion(TM) II Ultra Dual-Core Mobile M Processor Family", 
          "AMD Turion(TM) II Dual-Core Mobile M Processor Family", 
          "AMD Athlon(TM) II Dual-Core Mobile M Processor Family", 
          "AMD Opteron(TM) 6100 Series Processor", 
          "AMD Opteron(TM) 4100 Series Processor", 
          "AMD Opteron(TM) 6200 Series Processor", 
          "AMD Opteron(TM) 4200 Series Processor", 
          "AMD FX(TM) Series Processor", 
          // 64                     
          "MIPS Family", 
          "MIPS R4000", "MIPS R4200", "MIPS R4400", "MIPS R4600", 
          "MIPS R10000", "AMD C-Series Processor", 
          "AMD E-Series Processor", "AMD A-Series Processor", 
          "AMD G-Series Processor", "AMD Z-Series Processor", 
          "AMD R-Series Processor", 
          "AMD Opteron(TM) 4300 Series Processor", 
          "AMD Opteron(TM) 6300 Series Processor", 
          "AMD Opteron(TM) 3300 Series Processor", 
          "AMD FirePro(TM) Series Processor", 
          // 80                     
          "SPARC Family", 
          "SuperSPARC", "microSPARC II", "microSPARC IIep", 
          "UltraSPARC", "UltraSPARC II", "UltraSPARC IIi", 
          "UltraSPARC III", "UltraSPARC IIIi", 
          // 96                     
          "68040", 
          "68xxx Family", "68000", "68010", "68020", "68030", 
          "AMD Athlon(TM) X4 Quad-Core Processor Family", 
          "AMD Opteron(TM) X1000 Series Processor", 
          "AMD Opteron(TM) X2000 Series APU", 
          // 112                     
          "Hobbit Family", 
          "Crusoe(TM) TM5000 Family", "Crusoe(TM) TM3000 Family", 
          "Efficeon(TM) TM8000 Family", "Weitek", 
          "Itanium(TM) Processor", 
          "AMD Athlon(TM) 64 Processor Family", 
          "AMD Opteron(TM) Processor Family", 
          "AMD Sempron(TM) Processor Family", 
          "AMD Turion(TM) 64 Mobile Technology", 
          // 135                   
          "Dual-Core AMD Opteron(TM) Processor Family", 
          "AMD Athlon(TM) 64 X2 Dual-Core Processor Family", 
          "AMD Turion(TM) 64 X2 Mobile Technology", 
          "Quad-Core AMD Opteron(TM) Processor Family", 
          "Third-Generation AMD Opteron(TM) Processor Family", 
          "AMD Phenom(TM) FX Quad-Core Processor Family", 
          "AMD Phenom(TM) X4 Quad-Core Processor Family", 
          "AMD Phenom(TM) X2 Dual-Core Processor Family", 
          "AMD Athlon(TM) X2 Dual-Core Processor Family", 
          // 144                     
          "PA-RISC Family", 
          "PA-RISC 8500", "PA-RISC 8000", "PA-RISC 7300LC", 
          "PA-RISC 7200", "PA-RISC 7100LC", "PA-RISC 7100", 
          // 160                     
          "V30 Family", 
          // 161 
          "Quad-Core Intel(R) Xeon(R) processor 3200 Series", 
          "Dual-Core Intel(R) Xeon(R) processor 3000 Series", 
          "Quad-Core Intel(R) Xeon(R) processor 5300 Series", 
          "Dual-Core Intel(R) Xeon(R) processor 5100 Series", 
          "Dual-Core Intel(R) Xeon(R) processor 5000 Series", 
          "Dual-Core Intel(R) Xeon(R) processor LV", 
          "Dual-Core Intel(R) Xeon(R) processor ULV", 
          "Dual-Core Intel(R) Xeon(R) processor 7100 Series", 
          "Quad-Core Intel(R) Xeon(R) processor 5400 Series", 
          "Quad-Core Intel(R) Xeon(R) processor", 
          "Dual-Core Intel(R) Xeon(R) processor 5200 Series", 
          "Dual-Core Intel(R) Xeon(R) processor 7200 Series", 
          "Quad-Core Intel(R) Xeon(R) processor 7300 Series", 
          "Quad-Core Intel(R) Xeon(R) processor 7400 Series", 
          "Multi-Core Intel(R) Xeon(R) processor 7400 Series", 
          // 176 
          "Pentium(R) III Xeon(TM)", 
          "Pentium(R) III Processor with Intel(R) SpeedStep(TM) Technology", 
          "Pentium(R) 4", "Intel(R) Xeon(TM)", 
          // 180                     
          "AS400 Family", 
          "Intel(R) Xeon(TM) processor MP", 
          "AMD Athlon(TM) XP Family", "AMD Athlon(TM) MP Family", 
          "Intel(R) Itanium(R) 2", 
          "Intel(R) Pentium(R) M processor", 
          "Intel(R) Celeron(R) D processor", 
          "Intel(R) Pentium(R) D processor", 
          "Intel(R) Pentium(R) Processor Extreme Edition", 
          "Intel(R) Core(TM) Solo Processor", 
          // 190                     
          "K7", 
          "Intel(R) Core(TM)2 Duo Processor", 
          "Intel(R) Core(TM)2 Solo processor", 
          "Intel(R) Core(TM)2 Extreme processor", 
          "Intel(R) Core(TM)2 Quad processor", 
          "Intel(R) Core(TM)2 Extreme mobile processor", 
          "Intel(R) Core(TM)2 Duo mobile processor", 
          "Intel(R) Core(TM)2 Solo mobile processor", 
          "Intel(R) Core(TM) i7 processor", 
          "Dual-Core Intel(R) Celeron(R) Processor", 
          // 200                     
          "S/390 and zSeries Family", 
          "ESA/390 G4", "ESA/390 G5", "ESA/390 G6", 
          "z/Architectur base", 
          // 205
          "Intel(R) Core(TM) i5 processor", 
          "Intel(R) Core(TM) i3 processor", 
          // 210                   
          "VIA C7(TM)-M Processor Family", 
          "VIA C7(TM)-D Processor Family", 
          "VIA C7(TM) Processor Family", 
          "VIA Eden(TM) Processor Family", 
          "Multi-Core Intel(R) Xeon(R) processor", 
          "Dual-Core Intel(R) Xeon(R) processor 3xxx Series", 
          "Quad-Core Intel(R) Xeon(R) processor 3xxx Series", 
          "VIA Nano(TM) Processor Family", 
          "Dual-Core Intel(R) Xeon(R) processor 5xxx Series", 
          "Quad-Core Intel(R) Xeon(R) processor 5xxx Series", 
          // 221
          "Dual-Core Intel(R) Xeon(R) processor 7xxx Series", 
          "Quad-Core Intel(R) Xeon(R) processor 7xxx Series", 
          "Multi-Core Intel(R) Xeon(R) processor 7xxx Series", 
          "Multi-Core Intel(R) Xeon(R) processor 3400 Series", 
          "AMD Opteron(TM) 3000 Series Processor", 
          "AMD Sempron(TM) II Processor Family", 
          // 230
          "Embedded AMD Opteron(TM) Quad-Core Processor Family", 
          "AMD Phenom(TM) Triple-Core Processor Family", 
          "AMD Turion(TM) Ultra Dual-Core Mobile Processor Family", 
          "AMD Turion(TM) Dual-Core Mobile Processor Family", 
          "AMD Athlon(TM) Dual-Core Processor Family", 
          "AMD Sempron(TM) SI Processor Family", 
          "AMD Phenom(TM) II Processor Family", 
          "AMD Athlon(TM) II Processor Family", 
          "Six-Core AMD Opteron(TM) Processor Family", 
          "AMD Sempron(TM) M Processor Family", 
          // 250                   
          "i860", "i960", 
          "Reserved (SMBIOS Extension)", 
          "Reserved (Un-initialized Flash Content - Lo)", "SH-3", 
          "SH-4", "ARM", "StrongARM", 
          // 300                   
          "6x86", "MediaGX", 
          "MII", "WinChip", "DSP", "Video Processor", 
          // 65534                   
          "Reserved (For Future Special Purpose Assignment)", 
          "Reserved (Un-initialized Flash Content - Hi)" }, 
       ModelCorrespondence { "CIM_Processor.Family" }]
   uint16 ProcessorFamily;

      [Description ( "See CIM_Processor.MaxClockSpeed for details." ), 
       ModelCorrespondence { "CIM_Processor.MaxClockSpeed" }, 
       PUnit ( "hertz * 10^6" )]
   uint32 ProcessorMaxClockSpeed;

      [Description ( "See CIM_Memory.BlockSize for details." ), 
       ModelCorrespondence { "CIM_Memory.BlockSize" }]
   uint64 MemoryBlockSize;

      [Description ( "See CIM_Memory.NumberOfBlocks for details." ), 
       ModelCorrespondence { "CIM_Memory.NumberOfBlocks" }]
   uint64 MemoryNumberOfBlocks;

      [Description ( "See CIM_Memory.ConsumableBlocks for details." ), 
       ModelCorrespondence { "CIM_Memory.ConsumableBlocks" }]
   uint64 MemoryConsumableBlocks;

      [Description ( 
          "The major number component of the current BIOS version "
          "information." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.MajorVersion" }]
   uint16 CurrentBIOSMajorVersion;

      [Description ( 
          "The minor number component of the current BIOS version "
          "information." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.MinorVersion" }]
   uint16 CurrentBIOSMinorVersion;

      [Description ( 
          "The revision number component of the current BIOS "
          "version information." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.RevisionNumber" }]
   uint16 CurrentBIOSRevisionNumber;

      [Description ( 
          "The build number component of the current BIOS version "
          "information." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.BuildNumber" }]
   uint16 CurrentBIOSBuildNumber;

      [Description ( 
          "The major number component of the version information "
          "for the current management firmware on this physical "
          "computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.MajorVersion" }]
   uint16 CurrentManagementFirmwareMajorVersion;

      [Description ( 
          "The minor number component of the version information "
          "for the current management firmware on this physical "
          "computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.MinorVersion" }]
   uint16 CurrentManagementFirmwareMinorVersion;

      [Description ( 
          "The revision number component of the version information "
          "for the current management firmware on this physical "
          "computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.RevisionNumber" }]
   uint16 CurrentManagementFirmwareRevisionNumber;

      [Description ( 
          "The build number component of the version information "
          "for the current management firmware on this physical "
          "computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.BuildNumber" }]
   uint16 CurrentManagementFirmwareBuildNumber;

      [Description ( 
          "The user-friendly name for the current management "
          "firmware on this physical computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.ElementName" }]
   string CurrentManagementFirmwareElementName;

      [Description ( 
          "The version string for the current management firmware "
          "on this physical computer system." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.VersionString" }]
   string CurrentManagementFirmwareVersionString;

      [Description ( 
          "Type information of the current or last running "
          "operating system on this physical computer system. See "
          "CIM_OperatingSystem.OSType for details." ), 
       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", "113", "114", "115", "116" }, 
       Values { "Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", 
          "DECNT", "Tru64 UNIX", "OpenVMS", "HPUX", "AIX", 
          //10 
          "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", 
          "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE", 
          //20 
          "NCR3000", "NetWare", "OSF", "DC/OS", 
          "Reliant UNIX", "SCO UnixWare", "SCO OpenServer", 
          "Sequent", "IRIX", "Solaris", //30 
          "SunOS", 
          "U6000", "ASERIES", "HP NonStop OS", "HP NonStop OSS", 
          "BS2000", "LINUX", "Lynx", "XENIX", "VM", 
          //40 
          "Interactive UNIX", "BSDUNIX", "FreeBSD", 
          "NetBSD", "GNU Hurd", "OS9", "MACH Kernel", "Inferno", 
          "QNX", "EPOC", //50 
          "IxWorks", "VxWorks", 
          "MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", 
          "Rhapsody", "Windows 2000", "Dedicated", 
          //60 
          "OS/390", "VSE", "TPF", "Windows (R) Me", 
          "Caldera Open UNIX", "OpenBSD", "Not Applicable", 
          "Windows XP", "z/OS", "Microsoft Windows Server 2003", 
          //70
          "Microsoft Windows Server 2003 64-Bit", 
          "Windows XP 64-Bit", "Windows XP Embedded", 
          "Windows Vista", "Windows Vista 64-Bit", 
          "Windows Embedded for Point of Service", 
          "Microsoft Windows Server 2008", 
          "Microsoft Windows Server 2008 64-Bit", "FreeBSD 64-Bit", 
          "RedHat Enterprise Linux", 
          //80
          "RedHat Enterprise Linux 64-Bit", 
          "Solaris 64-Bit", "SUSE", "SUSE 64-Bit", "SLES", 
          "SLES 64-Bit", "Novell OES", "Novell Linux Desktop", 
          "Sun Java Desktop System", "Mandriva", 
          //90
          "Mandriva 64-Bit", "TurboLinux", 
          "TurboLinux 64-Bit", "Ubuntu", "Ubuntu 64-Bit", "Debian", 
          "Debian 64-Bit", "Linux 2.4.x", "Linux 2.4.x 64-Bit", 
          "Linux 2.6.x", //100
          "Linux 2.6.x 64-Bit", 
          "Linux 64-Bit", "Other 64-Bit", 
          "Microsoft Windows Server 2008 R2", "VMware ESXi", 
          "Microsoft Windows 7", "CentOS 32-bit", "CentOS 64-bit", 
          "Oracle Linux 32-bit", "Oracle Linux 64-bit", 
          //110 
          "eComStation 32-bitx", 
          "Microsoft Windows Server 2011", 
          "Microsoft Windows Server 2012", "Microsoft Windows 8", 
          "Microsoft Windows 8 64-bit", 
          "Microsoft Windows Server 2012 R2" }, 
       ModelCorrespondence { "CIM_OperatingSystem.OSType" }]
   uint16 OSType;

      [Description ( 
          "Version information of the current or last running "
          "operating system on this physical computer system. See "
          "CIM_OperatingSystem.Version for details." ), 
       ModelCorrespondence { "CIM_OperatingSystem.Version" }]
   string OSVersion;

      [Description ( 
          "EnabledState of the current or last running operating "
          "system on this physcial computer system." ), 
       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_OperatingSystem.EnabledState" }]
   uint16 OSEnabledState;

      [Description ( 
          "The BIOS version information in string format." ), 
       ModelCorrespondence { "CIM_SoftwareIdentity.VersionString" }]
   string CurrentBIOSVersionString;

      [Description ( "See CIM_ComputerSystem.Dedicated for details." ), 
       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", "..", "32568..65535" }, 
       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", 
          "Storage Virtualizer", "Media Library", "ExtenderNode", 
          "NAS Head", "Self-contained NAS", "UPS", "IP Phone", 
          "Management Controller", "Chassis Manager", 
          "Host-based RAID controller", "Storage Device Enclosure", 
          "Desktop", "Laptop", "Virtual Tape Library", 
          "Virtual Library System", "Network PC/Thin Client", 
          "FC Switch", "Ethernet Switch", "DMTF Reserved", 
          "Vendor Reserved" }, 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_ComputerSystem.Dedicated", 
          "CIM_PhysicalComputerSystemView.OtherDedicatedDescriptions" }]
   uint16 Dedicated[];

      [Description ( 
          "See CIM_System.IdentifyingDescriptions for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_ComputerSystem.IdentifyingDescriptions", 
          "CIM_PhysicalComputerSystemView.OtherIdentifyingInfo" }]
   string IdentifyingDescriptions[];

      [Description ( 
          "See CIM_ComputerSystem.OtherDedicatedDescriptions for details."
           ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_ComputerSystem.OtherDedicatedDescriptions", 
          "CIM_PhysicalComputerSystemView.Dedicated" }]
   string OtherDedicatedDescriptions[];

      [Description ( 
          "See CIM_System.OtherIdentifyingInfo for details." ), 
       ArrayType ( "Indexed" ), 
       MaxLen ( 256 ), 
       ModelCorrespondence { 
          "CIM_ComputerSystem.OtherIdentifyingInfo", 
          "CIM_PhysicalComputerSystemView.IdentifyingDescriptions" }]
   string OtherIdentifyingInfo[];

      [Description ( 
          "See CIM_Processor.CurrentClockSpeed for details." ), 
       ModelCorrespondence { "CIM_Processor.CurrentClockSpeed" }, 
       PUnit ( "hertz * 10^6" )]
   uint32 ProcessorCurrentClockSpeed;

      [Description ( "See CIM_Sensor.SensorContext for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_NumericSensor.SensorContext", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdFatal" }]
   string NumericSensorContext[];

      [Description ( 
          "See CIM_NumericSensor.LowerThresholdCritical description "
          "for details." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.LowerThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdFatal" }]
   sint32 NumericSensorLowerThresholdCritical[];

      [Description ( 
          "See CIM_NumericSensor.LowerThresholdFatal description for details."
           ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.LowerThresholdFatal", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdFatal" }]
   sint32 NumericSensorLowerThresholdFatal[];

      [Description ( 
          "See CIM_NumericSensor.LowerThresholdNonCritical for details."
           ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_NumericSensor.LowerThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorElementName", 
          "CIM_PhysicalComputerSystemView.NumericSensorEnabledState", 
          "CIM_PhysicalComputerSystemView.NumericSensorHealthState", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentState", 
          "CIM_PhysicalComputerSystemView.NumericSensorPrimaryStatus", 
          "CIM_PhysicalComputerSystemView.NumericSensorBaseUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorUnitModifier", 
          "CIM_PhysicalComputerSystemView.NumericSensorRateUnits", 
          "CIM_PhysicalComputerSystemView.NumericSensorCurrentReading", 
          "CIM_PhysicalComputerSystemView.NumericSensorSensorType", 
          "CIM_PhysicalComputerSystemView.NumericSensorOtherSensorTypeDescription", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdNonCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdCritical", 
          "CIM_PhysicalComputerSystemView.NumericSensorUpperThresholdFatal" }]
   sint32 NumericSensorLowerThresholdNonCritical[];


      [Description ( 
          "An extrinsic method for changing the state of this "
          "physical computer system. Requests that the state of the "
          "element be changed to the value specified in the "
          "RequestedState parameter. When the requested state "
          "change takes place, the EnabledState and RequestedState "
          "will be the same. Invoking the RequestStateChange method "
          "multiple times could result in earlier requests being "
          "overwritten or lost.\n"
          "A return code of 0 shall indicate the state change was "
          "successfully initiated.\n"
          "A return code of 1 shall indicate that the method is not "
          "supported. A return code of 2 shall indicate that the "
          "method failed.\n"
          "A return code of 4096 shall indicate the state change "
          "was successfully initiated, a ConcreteJob has been "
          "created, and its reference returned in the output "
          "parameter Job." ), 
       ValueMap { "0", "1", "2", "4096", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Failed", "Job Started", "DMTF Reserved", "Vendor Reserved" }, 
       ModelCorrespondence { "CIM_ComputerSystem.RequestStateChange" }]
   uint32 RequestStateChange(
         [Description ( 
             "See "
             "CIM_ComputerSystem.RequestedStateChange.RequestedState "
             "for details." ), 
          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_ComputerSystem.RequestStateChange(RequestedState)" }]
      uint16 RequestedState, 
         [In ( false ), Out, Description ( 
             "May contain a reference to the ConcreteJob created "
             "to track the state transition initiated by the "
             "method invocation." )]
      CIM_ConcreteJob REF Job, 
         [Description ( 
             "See CIM_ComputerSystem.TimeoutPeriod for details." ), 
          ModelCorrespondence { 
             "CIM_ComputerSystem.RequestStateChange(TimeoutPeriod)" }]
      datetime TimeoutPeriod);

      [Description ( 
          "An extrinsic method for clearing a log on this physical "
          "computer system.\n"
          "Requests that the Log be cleared of all entries.\n"
          "The return value shall be 0 if the request was "
          "successfully executed, 1 if the request is not "
          "supported, and 2 if an error occurred. A return code of "
          "4096 shall indicate the request to clear log was "
          "successfully initiated, a ConcreteJob has been created, "
          "and its reference returned in the output parameter Job." ), 
       ValueMap { "0", "1", "2", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Failed", "DMTF Reserved", "Vendor Reserved" }]
   uint32 ClearLog(
         [Description ( 
             "Idenfier for the log that is requested to be cleared."
              ), 
          ModelCorrespondence { "CIM_RecordLog.InstanceID", 
             "CIM_PhysicalComputerSystemView.LogInstanceID" }]
      string LogInstanceID);

      [Description ( 
          "An extrinsic method for installing software on this "
          "physical computer system. If 0 is returned, the function "
          "completed successfully and no ConcreteJob instance was "
          "required. The return value shall be 1 if the request is "
          "not supported, and 2 if an error occurred. If 4096 is "
          "returned, a ConcreteJob will be started to to perform "
          "the install. The Job\'s reference will be returned in "
          "the output parameter Job." ), 
       ValueMap { "0", "1", "2", "4096", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Failed", "Job Started", "DMTF Reserved", "Vendor Reserved" }, 
       ModelCorrespondence { 
          "CIM_SoftwareInstallationService.InstallFromURI" }]
   uint32 InstallSoftwareFromURI(
         [In ( false ), Out, Description ( 
             "Reference to the job (may be null if job completed)."
              )]
      CIM_ConcreteJob REF Job, 
         [Description ( 
             "See CIM_SoftwareIdentity.Classifications for details."
              ), 
          ValueMap { "10", "11", "13", "14", "..", 
             "0x8000..0xFFFF" }, 
          Values { "Firmware", "BIOS/FCode", "Software Bundle", 
             "Management Firmware", "DMTF Reserved", 
             "Vendor Reserved" }, 
          ArrayType ( "Indexed" ), 
          ModelCorrespondence { 
             "CIM_SoftwareIdentity.Classifications" }]
      uint16 Classifications[], 
         [Description ( 
             "See "
             "CIM_SoftwareInstallationService.InstallFromURI.URI "
             "for details." ), 
          ModelCorrespondence { 
             "CIM_SoftwareInstallationService.InstallFromURI" }]
      string URI, 
         [Description ( 
             "See "
             "CIM_SoftwareInstallationService.InstallFromURI.InstallOptions "
             "for details." ), 
          ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", 
             "10", "11", "12", "13", "..", "32768..65535" }, 
          Values { "Defer target/system reset", 
             "Force installation", "Install", "Update", "Repair", 
             "Reboot", "Password", "Uninstall", "Log", 
             "SilentMode", "AdministrativeMode", 
             "ScheduleInstallAt", "DMTF Reserved", 
             "Vendor Specific" }, 
          ArrayType ( "Indexed" ), 
          ModelCorrespondence { 
             "CIM_SoftwareInstallationService.InstallFromURI(InstallOptions)", 
             "CIM_PhysicalComputerSystemView.InstallSoftwareFromURI(InstallOptionsValues)" }]
      uint16 InstallOptions[], 
         [Description ( 
             "See "
             "CIM_SoftwareInstallationService.InstallFromURI.InstallOptionsValues "
             "for details." ), 
          ArrayType ( "Indexed" ), 
          ModelCorrespondence { 
             "CIM_SoftwareInstallationService.InstallFromURI(InstallOptionsValues)", 
             "CIM_PhysicalComputerSystemView.InstallSoftwareFromURI(InstallOptions)" }]
      string InstallOptionsValues[]);

      [Description ( 
          "This method is used to change the order of boot sources "
          "for the persistent boot configuration specified by the "
          "property "
          "CIM_PhysicalComputerSystemView.PersistentBootConfigOrder." ), 
       ValueMap { "0", "1", "2", "4096", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Failed", "Job Started", "DMTF Reserved", "Vendor Reserved" }]
   uint32 ModifyPersistentBootConfigOrder(
         [Description ( 
             "An ordered array of strings representing the order "
             "of boot sources." ), 
          ModelCorrespondence { 
             "CIM_PhysicalComputerSystemView.StructuredBootString" }]
      string StructuredBootString[], 
         [In ( false ), Out, Description ( 
             "Reference to the job spawned if the operation "
             "continues after the method returns. (May be null "
             "if the task is completed)." )]
      CIM_ConcreteJob REF Job);

      [Description ( 
          "This method is used to set the one time boot source for "
          "the next boot on this computer system." ), 
       ValueMap { "0", "1", "2", "4096", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Failed", "Job Started", "DMTF Reserved", "Vendor Reserved" }]
   uint32 SetOneTimeBootSource(
         [Description ( 
             "A string representing the boot source for next boot."
              ), 
          ModelCorrespondence { 
             "CIM_PhysicalComputerSystemView.StructuredBootString" }]
      string StructuredBootString, 
         [In ( false ), Out, Description ( 
             "Reference to the job spawned if the operation "
             "continues after the method returns. (May be null "
             "if the task is completed)." )]
      CIM_ConcreteJob REF Job);

};
