// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved


#pragma namespace("\\\\.\\root")

instance of __Namespace{
	Name = "cimv2r5";
};

#pragma namespace("\\\\.\\root\\cimv2r5")


instance of __Win32Provider as $DataProv
{
    Name = "MS_VIEW_INSTANCE_PROVIDER";
    ClsId = "{AA70DDF4-E11C-11D1-ABB0-00C04FD9159E}";
    ImpersonationLevel = 1;
    PerUserInitialization = "True";
};

instance of __InstanceProviderRegistration
{
    Provider = $DataProv;
    SupportsPut = True;
    SupportsGet = True;
    SupportsDelete = True;
    SupportsEnumeration = True;
    QuerySupportLevels = {"WQL:UnarySelect"};
};
instance of __MethodProviderRegistration
{
    Provider = $DataProv;
};

		[Abstract, Description( "ManagedEement is an abstract class that provides a common "
		"superclass (or top of the inheritance tree) for the non-association classes "
		"in the CIM Schema."), DisplayName("Managed Elements (CIM)")]
class CIM_ManagedElement
{
		[DisplayName("Caption"), Description( "The Caption property is a short textual "
		"description (one-line string) of the object."), MaxLen( 64), 
		PropertySources{ "Caption"}: ToSubclass]
	STRING Caption;
		[DisplayName("Description"), Description( "The Description property provides a "
		"textual description of the object."), PropertySources{ "Description"}: ToSubclass]
	STRING Description;
};
		[Abstract, Description( "CIM_ManagedSystemElement is the base class for the System "
		"Element hierarchy. Membership Criteria: Any distinguishable component of "
		"a System is a candidate for inclusion in this class. Examples: software components, "
		"such as files; and devices, such as disk drives and controllers, and physical "
		"components such as chips and cards."),DisplayName("Managed System Elements (CIM)")]
class CIM_ManagedSystemElement:CIM_ManagedElement
{
		[DisplayName("Install Date"), 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"}, 
		PropertySources{ "InstallDate"}: ToSubclass]
	DATETIME InstallDate;

		[DisplayName("Name"), 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( 256), PropertySources{ "Name"}: ToSubclass]
	STRING Name;

		[Description( "A String indicating the current status of the Object. Various "
		"operationaL and nON-operational statuses are defined. Operational statuses "
		"are \"OK\", \"DeGrAded\", \"Stressed\" aND \"Pred Fail\". \"STressed\" indicates "
		"that the Element is functioning, but needs attention. Examples of \"Stressed\" "
		"states are overload, overheated, etc. The condition \"Pred Fail\" (failure "
		"predicted) indicates that an Element is functioning properly but predicting "
		"a failure in the near future. An example is a SMART-enabled hard drive. /n "
		" Non-operational statuses can also be specified. These are \"Error\", \"NonRecover\", "
		"\"Starting\", \"Stopping\",  \"Stopped\", \"Service\", \"No Contact\" and "
		"\"Lost Comm\". \"NonRecover\" indicates that a non-recoverable error has "
		"occurred. \"Service\" describes an Element being configured, maintained, "
		"cleaned, or otherwise administered. This status could apply during mirror-resilvering "
		"of a disK, reload of a uSer permissions list, or other administrative task. "
		"Not all such work is on-line, yet the Element is neither \"OK\" nor in one "
		"oF the OtheR stAtes. \"No Contact\" indicates that the current instance of "
		"the monitoring system has knowledge of this ELement but has never been abLe "
		"To establisH communications with it. \"Lost Comm\" indicatEs that the ManagedSystemElement "
		"is known to exist and has been contacted successFully In the paSt, but is "
		"currently unreacHable.\"Stopped\" indicates that the ManagedSystemElement "
		"is known to exist, it is not operational (i.e. it is unable to provide service "
		"to users), but it has not failed. It has purposely been made non-operational. "
		"The Element may have never been \"OK\", the Element may have initiated its "
		"own stop, or a management system may have initiated the stop."), 
		MaxLen(10), ValueMap{ "OK", "Error", "Degraded", "Unknown", "Pred Fail", "Starting", 
		"Stopping", "Service", "Stressed", "NonRecover", "No Contact", "Lost Comm", "Stopped"}, 
		PropertySources{ "Status"}: ToSubclass, DisplayName("Status")]
	STRING Status;
};
		[abstract, Description( "The CIM_LogicalElement class is the base class for all "
		"the components of the system that represent abstract system components./nExample: "
		"profiles, processes, or system capabilities in the form of logical devices."): 
		ToSubclass, DisplayName("Logical Elements (CIM)"), Locale( 
		1033), UUID( "{8502C518-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_LogicalElement:CIM_ManagedSystemElement
{
};
	[abstract, Description( "The CIM_LogicalFile class represents a named collection "
				"of data (this can be executable code) located in a file system on a storage "
				"extent."): ToSubclass, DisplayName("Files (CIM)"): ToInstance  ToSubclass, Locale( 
		1033), SupportsDelete, UUID( "{8502C559-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_LogicalFile:CIM_LogicalElement
{
		[BitMap{ "0", "1", "2", "3", "4", "5", "6", "7", "8", "16", "17", "18", "19", 
		"20"}: ToSubclass, BitValues{ "FILE_READ_DATA (file) or FILE_LIST_DIRECTORY (directory)", 
		"FILE_WRITE_DATA (file) or FILE_ADD_FILE (directory)", "FILE_APPEND_DATA (file) "
				"or FILE_ADD_SUBDIRECTORY (directory)", "FILE_READ_EA", "FILE_WRITE_EA", "FILE_EXECUTE "
				"(file) or FILE_TRAVERSE (directory)", "FILE_DELETE_CHILD (directory)", "FILE_READ_ATTRIBUTES", 
		"FILE_WRITE_ATTRIBUTES", "DELETE", "READ_CONTROL", "WRITE_DAC", "WRITE_OWNER", 
		"SYNCHRONIZE"}: ToSubclass, Description( "The AccessMask property is a bit array "
				"representing the access rights to the given file or directory held by the "
				"user or group on whose behalf the instance is returned. This property is "
				"only supported under Windows NT and Windows 2000. On Windows 98 and on Windows "
				"NT/2000 FAT volumes, FULL_ACCESS is returned, indicating no security has "
				"been set on the object."): ToSubclass, DisplayName( "Access Rights"): ToInstance 
		 ToSubclass, PropertySources{ "AccessMask"}: ToSubclass, read: ToSubclass, Schema( 
		"Win32"): ToInstance]
	UINT32 AccessMask;
		[Description( "The Archive property is a boolean value indicating that the file "
				"should be archived."): ToSubclass, DisplayName( "Should Be Archived"): ToInstance 
		 ToSubclass, PropertySources{ "Archive"}: ToSubclass, read: ToSubclass, Schema( 
		"Win32"): ToInstance]
	BOOLEAN Archive;
		[Description( "The Compressed property is a boolean value indicating that the "
				"file is compressed."): ToSubclass, DisplayName( "Compressed"): ToInstance 
		 ToSubclass, PropertySources{ "Compressed"}: ToSubclass, read: ToSubclass, Schema( 
		"Win32"): ToInstance]
	BOOLEAN Compressed;
		[Description( "The CompressionMethod property is a free form string indicating "
				"the algorithm or tool used to compress the logical file. If it is not possible "
				"(or not desired) to describe the compression scheme (perhaps because it is "
				"not known), use the following words: \"Unknown\" to represent that it is "
				"not known whether the logical file is compressed or not, \"Compressed\" to "
				"represent that the file is compressed but either its compression scheme is "
				"not known or not disclosed, and \"Not Compressed\" to represent that the "
				"logical file is not compressed."): ToSubclass, DisplayName( "Compression "
				"Method"): ToInstance  ToSubclass, PropertySources{ "CompressionMethod"}: 
		ToSubclass, read: ToSubclass]
	STRING CompressionMethod;
		[Description( "The CreationClassName property is a string indicating the name "
				"of this class."): ToSubclass, DisplayName( "Class Name"): ToInstance  ToSubclass, 
		key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "CreationClassName"}: 
		ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The CreationDate property is a datetime value indicating the file's "
				"creation date."): ToSubclass, DisplayName( "Creation Date"): ToInstance  
		ToSubclass, PropertySources{ "CreationDate"}: ToSubclass, read: ToSubclass]
	DATETIME CreationDate;
		[Description( "The CSCreationClassName property is a string indicating the class "
				"of the computer system."): ToSubclass, DisplayName( "Computer System Class "
				"Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance  ToSubclass, 
		Propagated( "CIM_FileSystem.CSCreationClassName"): ToSubclass, PropertySources{ 
		"CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The CSName property is a string indicating the name of the computer "
				"system."): ToSubclass, DisplayName( "Computer System Name"): ToInstance  
		ToSubclass, key: DisableOverride  ToInstance  ToSubclass, Propagated( "CIM_FileSystem.CSName"): 
		ToSubclass, PropertySources{ "CSName"}: ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "The Drive property is a string representing the drive letter (including "
				"colon) of the file. Example: c:"): ToSubclass, DisplayName( "Drive"): ToInstance 
		 ToSubclass, PropertySources{ "Drive"}: ToSubclass, read: ToSubclass, Schema( 
		"Win32"): ToInstance]
	STRING Drive;
		[Description( "The EightDotThreeFileName property is a string representing the "
				"DOS-compatible file name for this file./nExample: c:\\progra~1"): ToSubclass, 
		DisplayName( "Eight Dot Three File Name"): ToInstance  ToSubclass, PropertySources{ 
		"EightDotThreeFileName"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING EightDotThreeFileName;
		[Description( "The Encrypted property is a boolean value indicating that the file "
				"is encrypted."): ToSubclass, DisplayName( "Encrypted"): ToInstance  ToSubclass, 
		PropertySources{ "Encrypted"}: ToSubclass, read: ToSubclass, Schema( "Win32"): 
		ToInstance]
	BOOLEAN Encrypted;
		[Description( "The EncryptionMethod property is a free form string indicating "
				"the algorithm or tool used to encrypt the logical file. If it is not possible "
				"(or not desired) to describe the encryption scheme (perhaps for security "
				"reasons), use the following words: \"Unknown\" to represent that it is not "
				"known whether the logical file is encrypted or not, \"Encrypted\" to represent "
				"that the file is encrypted but either its encryption scheme is not known "
				"or not disclosed, and \"Not Encrypted\" to represent that the logical file "
				"is not encrypted."): ToSubclass, DisplayName( "Encryption Method"): ToInstance 
		 ToSubclass, PropertySources{ "EncryptionMethod"}: ToSubclass, read: ToSubclass]
	STRING EncryptionMethod;
		[Description( "The Extension property is a string representing the file's extension "
				"(without the dot). Example: txt, mof, mdb."): ToSubclass, DisplayName( "File "
				"Extension"): ToInstance  ToSubclass, PropertySources{ "Extension"}: ToSubclass, 
		read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING Extension;
		[Description( "The FileName property is a string representing the filename (without "
				"extension) of the file. Example: autoexec"): ToSubclass, DisplayName( "File "
				"Name"): ToInstance  ToSubclass, PropertySources{ "FileName"}: ToSubclass, 
		read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING FileName;
		[Description( "The FileSize property represents the size of the file (in bytes)."): 
		ToSubclass, DisplayName( "Size"): ToInstance  ToSubclass, PropertySources{ "FileSize"}: 
		ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 FileSize;
		[Description( "The FileType property is a string descriptor representing the file "
				"type (indicated by the Extension property)."): ToSubclass, DisplayName( "File "
				"Type"): ToInstance  ToSubclass, PropertySources{ "FileType"}: ToSubclass, 
		read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING FileType;
		[Description( "The FSCreationClassName property is a string indicating the class "
				"of the file system."): ToSubclass, DisplayName( "File System Class Name"): 
		ToInstance  ToSubclass, key: DisableOverride  ToInstance  ToSubclass, Propagated( 
		"CIM_FileSystem.CreationClassName"): ToSubclass, PropertySources{ "FSCreationClassName"}: 
		ToSubclass, read: ToSubclass]
	STRING FSCreationClassName;
		[Description( "The FSName property is string indicating the name of the file system."): 
		ToSubclass, DisplayName( "File System Name"): ToInstance  ToSubclass, key: DisableOverride 
		 ToInstance  ToSubclass, Propagated( "CIM_FileSystem.Name"): ToSubclass, PropertySources{ 
		"FSName"}: ToSubclass, read: ToSubclass]
	STRING FSName;
		[Description( "The Hidden property is a boolean value indicating if the file is "
				"hidden."): ToSubclass, DisplayName( "Hidden"): ToInstance  ToSubclass, PropertySources{ 
		"Hidden"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	BOOLEAN Hidden;
		[Description( "The InUseCount property is an integer indicating the number of "
				"'file opens' that are currently active against the file."): ToSubclass, DisplayName( 
		"Current File Open Count"): ToInstance  ToSubclass, PropertySources{ "InUseCount"}: 
		ToSubclass, read: ToSubclass]
	UINT64 InUseCount;
		[Description( "The LastAccessed property is a datetime value indicating the time "
				"the file was last accessed."): ToSubclass, DisplayName( "Last Accessed"): 
		ToInstance  ToSubclass, PropertySources{ "LastAccessed"}: ToSubclass, read: ToSubclass]
	DATETIME LastAccessed;
		[Description( "The LastModified property is a datetime value indicating the time "
				"the file was last modified."): ToSubclass, DisplayName( "Last Modified"): 
		ToInstance  ToSubclass, PropertySources{ "LastModified"}: ToSubclass, read: ToSubclass]
	DATETIME LastModified;
		[Description( "The Name property is a string representing the inherited name that "
				"serves as a key of a logical file instance within a file system. Full path "
				"names should be provided. Example: c:\\winnt\\system\\win.ini"): ToSubclass, 
		DisplayName( "Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, Override( "Name"), PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "The Path property is a string representing the path of the file. "
				"This includes leading and trailing backslashes. Example: \\windows\\system\\"): 
		ToSubclass, DisplayName( "Path"): ToInstance  ToSubclass, PropertySources{ "Path"}: 
		ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING Path;
		[Description( "The Readable property is a boolean value indicating if the file "
				"can be read."): ToSubclass, DisplayName( "Readable"): ToInstance  ToSubclass, 
		PropertySources{ "Readable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Readable;
		[Description( "The system property is a boolean value indicating if the file is "
				"a system file."): ToSubclass, DisplayName( "System File"): ToInstance  ToSubclass, 
		PropertySources{ "System"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	BOOLEAN System;
		[Description( "The Writeable property is a boolean value indicating if the file "
				"can be written."): ToSubclass, DisplayName( "Writeable"): ToInstance  ToSubclass, 
		PropertySources{ "Writeable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Writeable;
};
	[Description( "CIM_DataFile is a type of logical file that is a named collection "
				"of data or executable code./n<B>The behavior of the provider backing this "
				"class will be changed in future releases. Currently the provider returns "
				"both files on fixed disks as well as files on mapped logical disks. In the "
				"future, only instances of files on local fixed disks will be returned.<B>"): 
		ToSubclass, DisplayName("All Files (CIM)"): ToInstance  ToSubclass, dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C55A-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_DataFile"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DataFile:CIM_LogicalFile
{
		[Description( "Manufacturer string from version resource if one is present."): 
		ToSubclass, DisplayName( "Manufacturer"): ToInstance  ToSubclass, PropertySources{ 
		"Manufacturer"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING Manufacturer;
		[Description( "Version string from version resource if one is present."): ToSubclass, 
		DisplayName( "Version"): ToInstance  ToSubclass, PropertySources{ "Version"}: 
		ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING Version;
};
	[abstract, Description( "A device file is a special type of logical file that represents "
				"a device. This convention is useful for some operating systems that manage "
				"devices using a byte stream I/O model. The logical device that is associated "
				"with this file is specified using the CIM_DeviceAccessedByFile relationship."): 
		ToSubclass, Locale( 1033), UUID("{4333BD60-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_DeviceFile:CIM_LogicalFile
{
};
	[Description( "Directory is a type of file that logically groups data files 'contained' "
				"in it, and provides path information for the grouped files."): ToSubclass, 
		DisplayName("Directories (CIM)"): ToInstance  ToSubclass, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C55F-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Directory"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Directory:CIM_LogicalFile
{
};
	[abstract, Description( "A CIM_System is a LogicalElement that aggregates an enumerable "
				"set of Managed System Elements. The aggregation operates as a functional "
				"whole. Within any particular subclass of System, there is a well-defined "
				"list of Managed System Element classes whose instances must be aggregated."): 
		ToSubclass, Locale( 
		1033), UUID( "{8502C524-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_System:CIM_LogicalElement
{
		[Description( "The CreationClassName property 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."): ToSubclass, DisplayName{ 
		"CreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[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."): 
		ToSubclass, DisplayName( "Name"): ToInstance  ToSubclass, key: DisableOverride 
		 ToInstance  ToSubclass, Override( "Name"), PropertySources{ "Name"}: ToSubclass, 
		read: ToSubclass]
	STRING Name;
		[Description( "The CIM_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."): 
		ToSubclass, DisplayName{ "NameFormat"}, PropertySources{ "NameFormat"}: ToSubclass, 
		read: ToSubclass]
	STRING NameFormat;
		[Description( "A string that provides information on how the primary system owner "
				"can be reached (e.g. phone number, email address, ...)."): ToSubclass, DisplayName{ 
		"PrimaryOwnerContact"}, PropertySources{ "PrimaryOwnerContact"}: ToSubclass, 
		read: ToSubclass]
	STRING PrimaryOwnerContact;
		[Description( "The name of the primary system owner."): ToSubclass, DisplayName{ 
		"PrimaryOwnerName"}, MaxLen( 64): ToSubclass, PropertySources{ "PrimaryOwnerName"}: 
		ToSubclass, read: ToSubclass]
	STRING PrimaryOwnerName;
		[Description( "An array (bag) of strings that specify the roles this System plays "
				"in the IT-environment. Subclasses of System may override this property to "
				"define explicit Roles values. Alternately, a Working Group may describe the "
				"heuristics, conventions and guidelines for specifying Roles. For example, "
				"for an instance of a networking system, the Roles property might contain "
				"the string, 'Switch' or 'Bridge'."): ToSubclass, DisplayName{ "Roles"}, PropertySources{ 
		"Roles"}: ToSubclass, read: ToSubclass, write: ToSubclass]
	STRING Roles[];
};
	[abstract, Description( "A class derived from CIM_System that is a special collection "
				"of CIM_ManagedSystemElement instances. This collection provides compute capabilities "
				"and serves as aggregation point to associate one or more of the following "
				"elements: file system, operating system, processor and memory (volatile and/or "
				"non-volatile storage)."): ToSubclass, Locale( 1033), UUID( "{8502C525-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_ComputerSystem:CIM_System
{
		[Description( "The CIM_ComputerSystem object and its derivatives are Top Level "
				"Objects of CIM. They provide the scope for numerous components. Having unique "
				"CIM_System keys is required. A heuristic is defined to create the CIM_ComputerSystem "
				"name to attempt to always generate the same name, independent of discovery "
				"protocol. This prevents inventory and management problems where the same "
				"asset or entity is discovered multiple times, but can not be resolved to "
				"a single object. Use of the heuristic is optional, but recommended. /n/n "
				"The NameFormat property identifies how the computer system name is generated, "
				"using a heuristic. The heuristic is outlined, in detail, in the CIM V2 Common "
				"Model specification. It assumes that the documented rules are traversed in "
				"order, to determine and assign a name. The NameFormat values list defines "
				"the precedence order for assigning the computer system name. Several rules "
				"do map to the same Value. /n/n Note that the CIM_ComputerSystem Name calculated "
				"using the heuristic is the system's key value. Other names can be assigned "
				"and used for the CIM_ComputerSystem that better suit the business, using "
				"Aliases."): ToSubclass, DisplayName{ "NameFormat"}, Override( "NameFormat"), 
		PropertySources{ "NameFormat"}: ToSubclass, read: ToSubclass, ValueMap{ "IP", 
		"Dial", "HID", "NWA", "HWA", "X25", "ISDN", "IPX", "DCC", "ICD", "E.164", "SNA", 
		"OID/OSI", "Other"}: ToSubclass, Values{ "IP", "Dial", "HID", "NWA", "HWA", "X25", 
		"ISDN", "IPX", "DCC", "ICD", "E.164", "SNA", "OID/OSI", "Other"}: ToSubclass]
	STRING NameFormat;
};
	[Description( "A class derived from CIM_ComputerSystem that represents a desktop, "
				"mobile, network PC, server or other type of a single node computer system."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C526-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_UnitaryComputerSystem"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_UnitaryComputerSystem:CIM_ComputerSystem
{
		[Description( "This object contains the data needed to find either the initial "
				"load device (its key) or the boot service to request the operating system "
				"to start up. In addition, the load parameters (ie, a pathname and parameters) "
				"may also be specified."): ToSubclass, DisplayName{ "InitialLoadInfo"}, PropertySources{ 
		"InitialLoadInfo"}: ToSubclass, read: ToSubclass]
	STRING InitialLoadInfo[];
		[Description( "This object contains the data identifying either the initial load "
				"device (its key) or the boot service that requested the last operating system "
				"load. In addition, the load parameters (ie, a pathname and parameters) may "
				"also be specified."): ToSubclass, DisplayName{ "LastLoadInfo"}, PropertySources{ 
		"LastLoadInfo"}: ToSubclass, read: ToSubclass]
	STRING LastLoadInfo;
		[Description( "Indicates the specific power-related capabilities of a computer "
				"system and its associated running operating system. The values, 0=\"Unknown\", "
				"1=\"Not Supported\", and 2=\"Disabled\" are self-explanatory. The value, "
				"3=\"Enabled\" indicates that the power management features are currently "
				"enabled but the exact feature set is unknown or the information is unavailable. "
				"\"Power Saving Modes Entered Automatically\" (4) describes that a system "
				"can change its power state based on usage or other criteria. \"Power State "
				"Settable\" (5) indicates that the SetPowerState method is supported. \"Power "
				"Cycling Supported\" (6) indicates that the SetPowerState method can be invoked "
				"with the PowerState parameter set to 5 (\"Power Cycle\"). \"Timed Power On "
				"Supported\" (7) indicates that the SetPowerState method can be invoked with "
				"the PowerState parameter set to 5 (\"Power Cycle\") and the Time parameter "
				"set to a specific date and time, or interval, for power-on."): ToSubclass, 
		DisplayName{ "PowerManagementCapabilities"}, MappingStrings{ "MIF.DMTF|System "
				"Power Controls|001.2"}: ToSubclass, PropertySources{ "PowerManagementCapabilities"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Not Supported", "Disabled", 
		"Enabled", "Power Saving Modes Entered Automatically", "Power State Settable", 
		"Power Cycling Supported", "Timed Power On Supported"}: ToSubclass]
	UINT16 PowerManagementCapabilities[];
		[Description( "Boolean indicating that the ComputerSystem, with its running OperatingSystem, "
				"supports power management. This boolean does not indicate that power management "
				"features are currently enabled, or if enabled, what features are supported. "
				"Refer to the PowerManagementCapabilities array for this information. If this "
				"boolean is false, the integer value 1 for the string, \"Not Supported\", "
				"should be the only entry in the PowerManagementCapabilities array."): ToSubclass, 
		DisplayName{ "PowerManagementSupported"}, PropertySources{ "PowerManagementSupported"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN PowerManagementSupported;
		[Description( "Indicates the current power state of the computer system and its "
				"associated operating system. Regarding the power saving states, these are "
				"defined as follows: Value 4 (Unknown) indicates that the system is known "
				"to be in a power save mode, but its exact status in this mode is unknown; "
				"2 (Low Power Mode) indicates that the system is in a power save state but "
				"still functioning, and may exhibit degraded performance; 3 (Standby) describes "
				"that the system is not functioning but could be brought to full power 'quickly'; "
				"and value 7 (Warning) indicates that the computerSystem is in a warning state, "
				"though also in a power save mode."): ToSubclass, DisplayName{ "PowerState"}, 
		PropertySources{ "PowerState"}: ToSubclass, read: ToSubclass, Values{ "Unknown", 
		"Full Power", "Power Save - Low Power Mode", "Power Save - Standby", "Power Save "
				"- Unknown", "Power Cycle", "Power Off", "Power Save - Warning", "Power Save "
				"- Hibernate", "Power Save - Soft Off"}: ToSubclass]
	UINT16 PowerState;
		[Description( "If enabled (value = 4), the unitary computer system 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)."): ToSubclass, DisplayName{ "ResetCapability"}, 
		MappingStrings{ "MIF.DMTF|System Hardware Security|001.4"}: ToSubclass, PropertySources{ 
		"ResetCapability"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5"}: ToSubclass, Values{ "Other", "Unknown", "Disabled", "Enabled", "Not Implemented"}: 
		ToSubclass]
	UINT16 ResetCapability;
		[Description( "SetPowerState method defines the desired power state of a computer "
				"system and its running operating system, and when the system should be put "
				"into that state. The PowerState parameter is specified as one of the valid "
				"integer values defined for the property, PowerState. The Time parameter (for "
				"all state changes but 5, \"Power Cycle\") indicates when the power state "
				"should be set, either as a regular date-time value or as an interval value "
				"(where the interval begins when the method invocation is received). When "
				"the PowerState parameter is equal to 5, \"Power Cycle\", the Time parameter "
				"indicates when the system should power on again. power off is immediate. "
				"SetPowerState should return 0 if successful, 1 if the specified power state "
				"and time requests are not supported, and some other value if any other error "
				"occurred."): ToSubclass, DisplayName{ "SetPowerState"}, MethodSource{ "SetPowerState"}]
	UINT32 SetPowerState(
	
		[DisplayName{ "PowerState"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"PowerState"}: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8"}: 
		ToSubclass, Values{ "Full Power", "Power Save - Low Power Mode", "Power Save "
				"- Standby", "Power Save - Other", "Power Cycle", "Power Off", "Hibernate", 
		"Soft Off"}: ToSubclass]
			UINT16 PowerState,
		[DisplayName{ "Time"}, ID( 1): DisableOverride  ToInstance, IN, PropertySources{ 
		"Time"}: ToSubclass]
			DATETIME Time
	);
};
	[abstract, Description( " The CIM_ApplicationSystem class is used to represent "
				"an  application or a software system that supports a particular  business "
				"function and that can be managed as an independent  units. Such a system "
				"can be decomposed into its functional  components using the CIM_SoftwareFeature "
				"class. The software  features for a particular application or software system "
				"are  located using the CIM_ApplicationSystemSoftwareFeature  association. "
				" "): ToSubclass, 
		Locale( 1033), UUID( "{120BB700-DB2B-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ApplicationSystem:CIM_System
{
};
	[Abstract, Description( "The CIM_SystemResource class is an entity managed by BIOS and/or "
				"an operating system which is available for use by software and/or logical "
				"devices. Examples of Resources in the x86 environment are IRQs, DMA channels "
				"and memory mapped I/O."): ToSubclass, Locale( 1033), 
		Union, UUID( "{8502C519-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_SystemResource:CIM_LogicalElement
{
};
	[Description( "Personal Computer architecture Memory Mapped I/O. This class addresses "
				"both memory and port I/O resources. The property, MappedResource, defines "
				"whether memory or I/O is mapped (and for I/O whether the mapping is to a "
				"memory or a port space."): ToSubclass, Locale( 1033), UUID( "{8502C51B-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_MemoryMappedIO:CIM_SystemResource
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The scoping computer system's creation class name property."): 
		ToSubclass, DisplayName{ "CSCreationClassName"}, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_ComputerSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The scoping computer system's name."): ToSubclass, DisplayName{ 
		"CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_ComputerSystem.Name"): ToSubclass, PropertySources{ "CSName"}: 
		ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "The EndingAddress property contains the ending address of memory "
				"mapped I/O"): ToSubclass, DisplayName{ "EndingAddress"}, MappingStrings{ 
		"MIF.DMTF|Memory Mapped I/O|001.2"}: ToSubclass, PropertySources{ "EndingAddress"}: 
		ToSubclass, read: ToSubclass]
	UINT64 EndingAddress;
		[Description( "The StartingAddress property contains the starting address of memory "
				"mapped I/O. The hardware resource identifier property should be set to this "
				"value to construct the mapped I/O resource key."): ToSubclass, DisplayName{ 
		"StartingAddress"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"MIF.DMTF|Memory Mapped I/O|001.1"}: ToSubclass, PropertySources{ "StartingAddress"}: 
		ToSubclass, read: ToSubclass]
	UINT64 StartingAddress;
};
	[Description( "Personal computer architecture DMA."): ToSubclass,  
		dynamic: ToInstance, Locale( 1033), 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C523-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_DMA"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DMA:CIM_SystemResource
{
		[Description( "An integer indicating the DMA channel address size in bits. Permissible "
				"values are 8, 16, 32 or 64 bits. If unknown, enter 0."): ToSubclass, DisplayName{ 
		"AddressSize"}, MappingStrings{ "MIF.DMTF|System Resource DMA Info|001.3"}: ToSubclass, 
		PropertySources{ "AddressSize"}: ToSubclass, read: ToSubclass, Units( "Bits"): 
		ToSubclass, ValueMap{ "0", "8", "16", "32", "64"}: ToSubclass]
	UINT16 AddressSize;
		[Description( "The Availability property indicates the availability of the DMA."): 
		ToSubclass, DisplayName{ "Availability"}, MappingStrings{ "MIF.DMTF|DMA|001.2"}: 
		ToSubclass, PropertySources{ "Availability"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5"}: ToSubclass, Values{ "Other", "Unknown", "Available", 
		"In Use/Not Available", "In Use and Available/Shareable"}: ToSubclass]
	UINT16 Availability;
		[Description( "Indicate whether the DMA channel supports burst mode"): ToSubclass, 
		DisplayName{ "BurstMode"}, MappingStrings{ "MIF.DMTF|DMA|001.3"}: ToSubclass, 
		PropertySources{ "BurstMode"}: ToSubclass, read: ToSubclass]
	BOOLEAN BurstMode;
		[Description( "Indicates whether DMA may execute in 'count by byte' mode (value=4) "
				"or not (value=3).  Also, \"Other\" (1) and \"Unknown\" (2) may be defined."): 
		ToSubclass, DisplayName{ "ByteMode"}, MappingStrings{ "MIF.DMTF|System Resource "
				"DMA Info|001.7"}: ToSubclass, PropertySources{ "ByteMode"}: ToSubclass, read: 
		ToSubclass, ValueMap{ "1", "2", "3", "4"}: ToSubclass, Values{ "Other", "Unknown", 
		"Not execute in 'count by byte' mode", "Execute in 'count by byte' mode"}: ToSubclass]
	UINT16 ByteMode;
		[Description( "DMA channel timing.  For example, \"Type A\" (value =4) or \"Type "
				"F\" (6) could be specified."): ToSubclass, DisplayName{ "ChannelTiming"}, 
		MappingStrings{ "MIF.DMTF|System Resource DMA Info|001.9"}: ToSubclass, PropertySources{ 
		"ChannelTiming"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5", "6"}: ToSubclass, Values{ "Other", "Unknown", "ISA Compatible", "Type A", 
		"Type B", "Type F"}: ToSubclass]
	UINT16 ChannelTiming;
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The scoping computer system's creation class name."): ToSubclass, 
		DisplayName{ "CSCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, Propagated( "CIM_ComputerSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The scoping computer system's name."): ToSubclass, DisplayName{ 
		"CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_ComputerSystem.Name"): ToSubclass, PropertySources{ "CSName"}: 
		ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "A part of the object's key value, the DMA channel number."): ToSubclass, 
		DisplayName{ "DMAChannel"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"MIF.DMTF|DMA|001.1"}: ToSubclass, PropertySources{ "DMAChannel"}: ToSubclass, 
		read: ToSubclass]
	UINT32 DMAChannel;
		[Description( "The maximum number of bytes that can be transferred by this DMA "
				"channel.  If unknown, enter 0."): ToSubclass, DisplayName{ "MaxTransferSize"}, 
		MappingStrings{ "MIF.DMTF|System Resource DMA Info|001.4"}: ToSubclass, PropertySources{ 
		"MaxTransferSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT32 MaxTransferSize;
		[Description( "An array indicating all the transfer widths (in bits) supported "
				"by this DMA Channel. Permissible values are 8, 16, 32, 64 or 128 bits.  If "
				"unknown, enter 0."): ToSubclass, DisplayName{ "TransferWidths"}, MappingStrings{ 
		"MIF.DMTF|System Resource DMA Info|001.2"}: ToSubclass, PropertySources{ "TransferWidths"}: 
		ToSubclass, read: ToSubclass, Units( "Bits"): ToSubclass, ValueMap{ "0", "8", 
		"16", "32", "64", "128"}: ToSubclass]
	UINT16 TransferWidths[];
		[Description( "Indicates whether C type (burst) timing is supported (value=5) "
				"or not (value=4). Also, \"Other\" (1), \"Unknown\" (2) and \"ISA Compatible\" "
				"(3) are defined."): ToSubclass, DisplayName{ "TypeCTiming"}, MappingStrings{ 
		"MIF.DMTF|System Resource DMA Info|001.10"}: ToSubclass, PropertySources{ "TypeCTiming"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: ToSubclass, 
		Values{ "Other", "Unknown", "ISA Compatible", "Not Supported", "Supported"}: 
		ToSubclass]
	UINT16 TypeCTiming;
		[Description( "Indicates whether DMA may execute in 'count by word' mode (value=4) "
				"or not (value=3).  Also, \"Other\" (1) and \"Unknown\" (2) may be defined."): 
		ToSubclass, DisplayName{ "WordMode"}, MappingStrings{ "MIF.DMTF|System Resource "
				"DMA Info|001.8"}: ToSubclass, PropertySources{ "WordMode"}: ToSubclass, read: 
		ToSubclass, ValueMap{ "1", "2", "3", "4"}: ToSubclass, Values{ "Other", "Unknown", 
		"Not execute in 'count by word' mode", "Execute in 'count by word' mode"}: ToSubclass]
	UINT16 WordMode;
};
	[Description( "The CIM_IRQ class represents an Intel architecture IRQ"): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C51A-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_IRQ"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_IRQ:CIM_SystemResource
{
		[Description( "Availability of the IRQ."): ToSubclass, DisplayName{ "Availability"}, 
		MappingStrings{ "MIF.DMTF|IRQ|001.2"}: ToSubclass, PropertySources{ "Availability"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: ToSubclass, 
		Values{ "Other", "Unknown", "Available", "In Use/Not Available", "In Use and "
				"Available/Shareable"}: ToSubclass]
	UINT16 Availability;
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "CSCreationClassName contains the scoping computer system's creation "
				"class name."): ToSubclass, DisplayName{ "CSCreationClassName"}, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_ComputerSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "CSName contains the scoping computer system's name."): ToSubclass, 
		DisplayName{ "CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_ComputerSystem.Name"): ToSubclass, PropertySources{ 
		"CSName"}: ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "A part of the object's key value, IRQ Number."): ToSubclass, DisplayName{ 
		"IRQNumber"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "MIF.DMTF|IRQ|001.1"}: 
		ToSubclass, PropertySources{ "IRQNumber"}: ToSubclass, read: ToSubclass]
	UINT32 IRQNumber;
		[Description( "Boolean indicating whether the IRQ can be shared."): ToSubclass, 
		DisplayName{ "Shareable"}, MappingStrings{ "MIF.DMTF|IRQ|001.4"}: ToSubclass, 
		PropertySources{ "Shareable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Shareable;
		[Description( "IRQ trigger level indicating whether the interrupt is triggered "
				"by the hardware signal going high (value=4) or low (value=3).  Also, \"Other\" "
				"(1) and \"Unknown\" (2) may be defined."): ToSubclass, DisplayName{ "TriggerLevel"}, 
		MappingStrings{ "MIF.DMTF|System Resource IRQ Info|001.3"}: ToSubclass, PropertySources{ 
		"TriggerLevel"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4"}: 
		ToSubclass, Values{ "Other", "Unknown", "Active Low", "Active High"}: ToSubclass]
	UINT16 TriggerLevel;
		[Description( "IRQ trigger type indicating whether edge (value=4) or level triggered "
				"(value=3) interrupts occur. Also, \"Other\" (1) and \"Unknown\" (2) may be "
				"defined."): ToSubclass, DisplayName{ "TriggerType"}, MappingStrings{ "MIF.DMTF|IRQ|001.3", 
		"MIF.DMTF|System Resource IRQ Info|001.2"}: ToSubclass, PropertySources{ "TriggerType"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4"}: ToSubclass, Values{ 
		"Other", "Unknown", "Level", "Edge"}: ToSubclass]
	UINT16 TriggerType;
};
	[abstract, Description( "An abstraction or emulation of a hardware entity, that "
				"may or may not be realized in physical hardware. Any characteristics of logical "
				"devices that are used to manage its operation or configuration are contained "
				"in, or associated with, the CIM_LogicalDevice object. Examples of the operational "
				"properties for a printer would be paper sizes supported, or detected errors. "
				"Examples of the configuration properties of a sensor device would be threshold "
				"settings. Various configurations could exist for a logical device. These "
				"configurations could be contained in CIM_Setting objects and associated with "
				"the logical device."): ToSubclass, Locale( 1033), UUID( "{8502C529-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_LogicalDevice:CIM_LogicalElement
{
		[Description( "The availability and status of the device.  For example, the Availability "
				"property indicates that the device is running and has full power (value=3), "
				"or is in a warning (4), test (5), degraded (10) or power save state (values "
				"13-15 and 17). Regarding the power saving states, these are defined as follows: "
				"Value 13 (\"Power Save - Unknown\") indicates that the device is known to "
				"be in a power save mode, but its exact status in this mode is unknown; 14 "
				"(\"Power Save - Low Power Mode\") indicates that the device is in a power "
				"save state but still functioning, and may exhibit degraded performance; 15 "
				"(\"Power Save - Standby\") describes that the device is not functioning but "
				"could be brought to full power 'quickly'; and value 17 (\"Power Save - Warning\") "
				"indicates that the device is in a warning state, though also in a power save "
				"mode."): ToSubclass, DisplayName{ "Availability"}, MappingStrings{ "MIF.DMTF|Operational "
				"State|003.5", "MIB.IETF|HOST-RESOURCES-MIB.hrDeviceStatus"}: ToSubclass, 
		PropertySources{ "Availability"}: ToSubclass, read: ToSubclass, ValueMap{ "1", 
		"2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", 
		"17", "18", "19", "20", "21"}: ToSubclass, Values{ "Other", "Unknown", "Running/Full "
				"Power", "Warning", "In Test", "Not Applicable", "Power Off", "Off Line", 
		"Off Duty", "Degraded", "Not Installed", "Install Error", "Power Save - Unknown", 
		"Power Save - Low Power Mode", "Power Save - Standby", "Power Cycle", "Power "
				"Save - Warning", "Paused", "Not Ready", "Not Configured", "Quiesced"}: ToSubclass]
	UINT16 Availability;
		[Description( "Indicates the Win32 Configuration Manager error code."): ToSubclass, 
		DisplayName{ "ConfigManagerErrorCode"}, PropertySources{ "ConfigManagerErrorCode"}: 
		ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance, Values{ "This device "
				"is working properly.", "This device is not configured correctly.", "Windows "
				"cannot load the driver for this device.", "The driver for this device might "
				"be corrupted, or your system may be running low on memory or other resources.", 
		"This device is not working properly. One of its drivers or your registry might "
				"be corrupted.", "The driver for this device needs a resource that Windows "
				"cannot manage.", "The boot configuration for this device conflicts with other "
				"devices.", "Cannot filter.", "The driver loader for the device is missing.", 
		"This device is not working properly because the controlling firmware is reporting "
				"the resources for the device incorrectly.", "This device cannot start.", 
		"This device failed.", "This device cannot find enough free resources that it "
				"can use.", "Windows cannot verify this device's resources.", "This device "
				"cannot work properly until you restart your computer.", "This device is not "
				"working properly because there is probably a re-enumeration problem.", "Windows "
				"cannot identify all the resources this device uses.", "This device is asking "
				"for an unknown resource type.", "Reinstall the drivers for this device.", 
		"Your registry might be corrupted.", "System failure: Try changing the driver "
				"for this device. If that does not work, see your hardware documentation.Windows "
				"is removing this device.", "This device is disabled.", "System failure: Try "
				"changing the driver for this device. If that doesn't work, see your hardware "
				"documentation.", "This device is not present, is not working properly, or "
				"does not have all its drivers installed.", "Windows is still setting up this "
				"device.", "Windows is still setting up this device.", "This device does not "
				"have valid log configuration.", "The drivers for this device are not installed.", 
		"This device is disabled because the firmware of the device did not give it the "
				"required resources.", "This device is using an Interrupt Request (IRQ) resource "
				"that another device is using.", "This device is not working properly because "
				"Windows cannot load the drivers required for this device."}: ToSubclass]
	UINT32 ConfigManagerErrorCode;
		[Description( "Indicates whether the device is using a user-defined configuration."): 
		ToSubclass, DisplayName{ "ConfigManagerUserConfig"}, PropertySources{ "ConfigManagerUserConfig"}: 
		ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	BOOLEAN ConfigManagerUserConfig;
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "CreationClassName"}: 
		ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "DeviceID is an address or other identifying information to uniquely "
				"name the logical device."): ToSubclass, DisplayName{ "DeviceID"}, key: DisableOverride 
		 ToInstance  ToSubclass, PropertySources{ "DeviceID"}: ToSubclass, read: ToSubclass]
	STRING DeviceID;
		[Description( "ErrorCleared is a boolean property indicating that the error reported "
				"in LastErrorCode property is now cleared."): ToSubclass, DisplayName{ "ErrorCleared"}, 
		PropertySources{ "ErrorCleared"}: ToSubclass, read: ToSubclass]
	BOOLEAN ErrorCleared;
		[Description( "ErrorDescription is a free-form string supplying more information "
				"about the error recorded in LastErrorCode property, and information on any "
				"corrective actions that may be taken."): ToSubclass, DisplayName{ "ErrorDescription"}, 
		PropertySources{ "ErrorDescription"}: ToSubclass, read: ToSubclass]
	STRING ErrorDescription;
		[Description( "LastErrorCode captures the last error code reported by the logical "
				"device."): ToSubclass, DisplayName{ "LastErrorCode"}, PropertySources{ "LastErrorCode"}: 
		ToSubclass, read: ToSubclass]
	UINT32 LastErrorCode;
		[Description( "Indicates the Win32 Plug and Play device ID of the logical device. "
				" Example: *PNP030b"): ToSubclass, DisplayName{ "PNPDeviceID"}, PropertySources{ 
		"PNPDeviceID"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	STRING PNPDeviceID;
		[Description( "Indicates the specific power-related capabilities of the logical "
				"device. The array values, 0=\"Unknown\", 1=\"Not Supported\" and 2=\"Disabled\" "
				"are self-explanatory. The value, 3=\"Enabled\" indicates that the power management "
				"features are currently enabled but the exact feature set is unknown or the "
				"information is unavailable. \"Power Saving Modes Entered Automatically\" "
				"(4) describes that a device can change its power state based on usage or "
				"other criteria. \"Power State Settable\" (5) indicates that the SetPowerState "
				"method is supported. \"Power Cycling Supported\" (6) indicates that the SetPowerState "
				"method can be invoked with the PowerState input variable set to 5 (\"Power "
				"Cycle\"). \"Timed Power On Supported\" (7) indicates that the SetPowerState "
				"method can be invoked with the PowerState input variable set to 5 (\"Power "
				"Cycle\") and the Time parameter set to a specific date and time, or interval, "
				"for power-on."): ToSubclass, DisplayName{ "PowerManagementCapabilities"}, 
		PropertySources{ "PowerManagementCapabilities"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Not Supported", "Disabled", "Enabled", "Power Saving Modes "
				"Entered Automatically", "Power State Settable", "Power Cycling Supported", 
		"Timed Power On Supported"}: ToSubclass]
	UINT16 PowerManagementCapabilities[];
		[Description( "Boolean indicating that the Device can be power managed - ie, put "
				"into a power save state. This boolean does not indicate that power management "
				"features are currently enabled, or if enabled, what features are supported. "
				"Refer to the PowerManagementCapabilities array for this information. If this "
				"boolean is false, the integer value 1, for the string, \"Not Supported\", "
				"should be the only entry in the PowerManagementCapabilities array."): ToSubclass, 
		DisplayName{ "PowerManagementSupported"}, PropertySources{ "PowerManagementSupported"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN PowerManagementSupported;
		[Description( "StatusInfo is a string indicating whether the logical device is "
				"in an enabled (value = 3), disabled (value = 4) or some other (1) or unknown "
				"(2) state. If this property does not apply to the logical device, the value, "
				"5 (\"Not Applicable\"), should be used."): ToSubclass, DisplayName{ "StatusInfo"}, 
		MappingStrings{ "MIF.DMTF|Operational State|003.3"}: ToSubclass, PropertySources{ 
		"StatusInfo"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: 
		ToSubclass, Values{ "Other", "Unknown", "Enabled", "Disabled", "Not Applicable"}: 
		ToSubclass]
	UINT16 StatusInfo;
		[Description( "The scoping System's CreationClassName."): ToSubclass, DisplayName{ 
		"SystemCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, Propagated( 
		"CIM_System.CreationClassName"): ToSubclass, PropertySources{ "SystemCreationClassName"}: 
		ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The scoping System's Name."): ToSubclass, DisplayName{ "SystemName"}, 
		key: DisableOverride  ToInstance  ToSubclass, Propagated( "CIM_System.Name"): 
		ToSubclass, PropertySources{ "SystemName"}: ToSubclass, read: ToSubclass]
	STRING SystemName;
		[Description( "SetPowerState defines the desired power state for a logical device "
				"and when a device should be put into that state. The desired power state "
				"is specified by setting the PowerState parameter to one of the following "
				"integer values: 1=\"Full Power\", 2=\"Power Save - Low Power Mode\", 3=\"Power "
				"Save - Standby\", 4=\"Power Save - Other\", 5=\"Power Cycle\" or 6=\"Power "
				"Off\". The Time parameter (for all state changes, except 5, \"Power Cycle\") "
				"indicates when the power state should be set, either as a regular date-time "
				"value or as an interval value (where the interval begins when the method "
				"invocation is received). When the PowerState parameter is equal to 5, \"Power "
				"Cycle\", the Time parameter indicates when the device should power on again. "
				"Power off is immediate. SetPowerState should return 0 if successful, 1 if "
				"the specified PowerState and Time request is not supported, and some other "
				"value if any other error occurred. In a subclass, the set of possible return "
				"codes could be specified, using a ValueMap qualifier on the method. The strings "
				"to which the ValueMap contents are 'translated' may also be specified in "
				"the subclass as a Values array qualifier."): ToSubclass, DisplayName{ "SetPowerState"}, 
		MethodSource{ "SetPowerState"}]
	UINT32 SetPowerState(
	
		[DisplayName{ "PowerState"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"PowerState"}: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6"}: ToSubclass, 
		Values{ "Full Power", "Power Save - Low Power Mode", "Power Save - Standby", 
		"Power Save - Other", "Power Cycle", "Power Off"}: ToSubclass]
			UINT16 PowerState,
		[DisplayName{ "Time"}, ID( 1): DisableOverride  ToInstance, IN, PropertySources{ 
		"Time"}: ToSubclass]
			DATETIME Time
	);
		[Description( "Requests a reset of the logical device. The return value should "
				"be 0 if the request was successfully executed, 1 if the request is not supported "
				"and some other value if an error occurred."): ToSubclass, DisplayName{ "Reset"}, 
		MethodSource{ "Reset"}]
	UINT32 Reset();
};
	[abstract, Description( "StorageExtent describes the capabilities and management "
				"of the various media that exist to store data and allow data retrieval. This "
				"superclass could be used to represent the various components of RAID (Hardware "
				"or Software) or as a raw logical extent on top of physical media."): ToSubclass, 
		Locale( 1033), UUID( 
		"{8502C538-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_StorageExtent:CIM_LogicalDevice
{
		[Description( "Access describes whether the media is readable (value=1), writeable "
				"(value=2), or both (value=3). \"Unknown\" (0) and \"Write Once\" (4) can "
				"also be defined."): ToSubclass, DisplayName{ "Access"}, PropertySources{ 
		"Access"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Readable", "Writeable", 
		"Read/Write Supported", "Write Once"}: ToSubclass]
	UINT16 Access;
		[Description( "Size in bytes of the blocks which form this StorageExtent. If variable "
				"block size, then the maximum block size in bytes should be specified. If "
				"the block size is unknown or if a block concept is not valid (for example, "
				"for Aggregate Extents, Memory or LogicalDisks), enter a 1."): ToSubclass, 
		DisplayName{ "BlockSize"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrStorageAllocationUnits"}: 
		ToSubclass, PropertySources{ "BlockSize"}: ToSubclass, read: ToSubclass, Units( 
		"Bytes"): ToSubclass]
	UINT64 BlockSize;
		[Description( "ErrorMethodology is a free-form string describing the type of error "
				"detection and correction supported by this storage extent."): ToSubclass, 
		DisplayName{ "ErrorMethodology"}, PropertySources{ "ErrorMethodology"}: ToSubclass, 
		read: ToSubclass]
	STRING ErrorMethodology;
		[Description( "Total number of consecutive blocks, each block the size of the "
				"value contained in the BlockSize property, which form this storage extent. "
				"Total size of the storage extent can be calculated by multiplying the value "
				"of the BlockSize property by the value of this property. If the value of "
				"BlockSize is 1, this property is the total size of the storage extent."): 
		ToSubclass, DisplayName{ "NumberOfBlocks"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrStorageSize"}: 
		ToSubclass, PropertySources{ "NumberOfBlocks"}: ToSubclass]
	UINT64 NumberOfBlocks;
		[Description( "A free form string describing the media and/or its use."): ToSubclass, 
		DisplayName{ "Purpose"}, PropertySources{ "Purpose"}: ToSubclass, read: ToSubclass]
	STRING Purpose;
};
	[Description( "A LogicalDisk is a presentation of a contiguous range of logical "
				"blocks that is identifiable by a FileSystem via the Disk's DeviceId (key) "
				"field. For example in a Windows environment, the DeviceID field would contain "
				"a drive letter. In a Unix environment, it would contain the access path; "
				"and in a NetWare environment, DeviceID would contain the volume name. LogicalDisks "
				"are typically built on a DiskPartition or StorageVolume (for example, exposed "
				"by a software volume manager) using the LogicalDiskBasedOnPartition or LogicalDiskBasedOnVolume "
				"associations. However, it can be based on other StorageExtents, like CIM_Memory, "
				"in the case of a RAM disk. The latter is described using the LogicalDiskBasedOnExtent "
				"relationship. (Indeed, the BasedOnExtent association is the superclass for "
				"the BasedOnPartition and BasedOnVolume relationships.)"): ToSubclass, dynamic: ToInstance, 
				Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C539-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_LogicalDisk"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_LogicalDisk:CIM_StorageExtent
{
		[Description( "The FreeSpace property indicates in bytes how much free space is "
				"available on the logical disk."): ToSubclass, DisplayName{ "FreeSpace"}, 
		PropertySources{ "FreeSpace"}: ToSubclass, read: ToSubclass, units( "Bytes"): 
		ToSubclass]
	UINT64 FreeSpace;
		[Description( "The Size property indicates in bytes, the size of the logical disk."): 
		ToSubclass, DisplayName{ "Size"}, PropertySources{ "Size"}: ToSubclass, read: 
		ToSubclass, units( "Bytes"): ToSubclass]
	UINT64 Size;
};
	[abstract, Description( "CIM_VolumeSet represents a contiguous range of logical "
				"blocks presented to the operating environment for reading and writing user "
				"data.  Volume sets shall not overlap one another. They are based on one or "
				"more physical extents, protected space extents, or aggregate extents (all "
				"of the same type). These based on associations should be instantiated or "
				"subclassed as needed."): ToSubclass, Locale( 1033), UUID( "{35E25AA5-E3D1-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_VolumeSet:CIM_StorageExtent
{
		[Description( "VolumeSets in SCC have additional status information beyond that "
				"captured in the Availability and StatusInfo properties, inherited from ManagedSystemElement. "
				"This additional information (for example, \"Protection Disabled\", value=9) "
				"is captured in the VolumeStatus property."): ToSubclass, DisplayName{ "PSExtentInterleaveDepth"}, 
		MappingStrings{ "MIF.DMTF|Volume Set|001.5"}: ToSubclass, PropertySources{ "PSExtentInterleaveDepth"}: 
		ToSubclass, read: ToSubclass]
	UINT64 PSExtentInterleaveDepth;
		[Description( "Number of contiguous ProtectedSpaceExtents counted before looping "
				"back to the first ProtectedSpaceExtent of the current stripe. It is the number "
				"of Extents forming the user data stripe."): ToSubclass, DisplayName{ "PSExtentStripeLength"}, 
		MappingStrings{ "MIF.DMTF|Volume Set|001.4"}: ToSubclass, PropertySources{ "PSExtentStripeLength"}: 
		ToSubclass, read: ToSubclass]
	UINT64 PSExtentStripeLength;
};
	[abstract, Description( "The CIM_AggregatePExtent class provides summary information "
				"about the addressable logical blocks which are in the same storage redundancy "
				"group and reside on the same physical media. This is an alternative grouping "
				"for physical extents, when only summary information is needed or when automatic "
				"configuration is used. Automatic configuration can result in thousands of "
				"physical extents being defined. There is no value in modeling the individual "
				"extents.  So, the CIM_AggregatePExtent object was defined."): ToSubclass, 
		Locale( 1033), UUID( 
		"{9565979F-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_AggregatePExtent:CIM_StorageExtent
{
		[Description( "Total number of blocks (including the check data blocks) contained "
				"in this aggregate physical extent.  The block size (an inherited property) "
				"should be set to the same value as for the media access device associated "
				"with this extent."): ToSubclass, DisplayName{ "NumberOfBlocks"}, MappingStrings{ 
		"MIF.DMTF|Aggregate Physical Extent|001.2"}: ToSubclass, Override( "NumberOfBlocks"), 
		PropertySources{ "NumberOfBlocks"}: ToSubclass, read: ToSubclass]
	UINT64 NumberOfBlocks;
};
	[abstract, Description( "A PhysicalExtent is used to model an SCC RAID implementation. "
				"It defines the consecutive addressable block addresses on a single storage "
				"device, that are treated as a single StorageExtent and that are in the same "
				"StorageRedundancyGroup. An alternate possibility, if automatic configuration "
				"is used, is to instantiate or extend the AggregatePExtent class."): ToSubclass, 
		Locale( 1033), UUID( 
		"{9565979E-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_PhysicalExtent:CIM_StorageExtent
{
		[Description( "Size in bytes of the blocks which form this StorageExtent. If variable "
				"block size, then the maximum block size in bytes should be specified. If "
				"the block size is unknown or if a block concept is not valid (for example, "
				"for Aggregate Extents, Memory or LogicalDisks), enter a 1."): ToSubclass, 
		DisplayName{ "BlockSize"}, MappingStrings{ "MIF.DMTF|Physical Extent|001.4"}: 
		ToSubclass, Override( "BlockSize"), PropertySources{ "BlockSize"}: ToSubclass, 
		read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 BlockSize;
		[Description( "Total number of consecutive blocks, each block the size of the "
				"value contained in the BlockSize property, which form this storage extent. "
				"Total size of the storage extent can be calculated by multiplying the value "
				"of the BlockSize property by the value of this property. If the value of "
				"BlockSize is 1, this property is the total size of the storage extent."): 
		ToSubclass, DisplayName{ "NumberOfBlocks"}, MappingStrings{ "MIF.DMTF|Physical "
				"Extent|001.3"}: ToSubclass, Override( "NumberOfBlocks"), PropertySources{ 
		"NumberOfBlocks"}: ToSubclass, read: ToSubclass]
	UINT64 NumberOfBlocks;
		[Description( "Number of bytes of user data to skip before starting the check "
				"data interleave."): ToSubclass, DisplayName{ "UnitsBeforeCheckDataInterleave"}, 
		MappingStrings{ "MIF.DMTF|Physical Extent|001.6"}: ToSubclass, PropertySources{ 
		"UnitsBeforeCheckDataInterleave"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 UnitsBeforeCheckDataInterleave;
		[Description( "Number of bytes to be reserved for check data."): ToSubclass, DisplayName{ 
		"UnitsOfCheckData"}, MappingStrings{ "MIF.DMTF|Physical Extent|001.7"}: ToSubclass, 
		PropertySources{ "UnitsOfCheckData"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 UnitsOfCheckData;
		[Description( "Number of bytes to be reserved for user data."): ToSubclass, DisplayName{ 
		"UnitsOfUserData"}, MappingStrings{ "MIF.DMTF|Physical Extent|001.8"}: ToSubclass, 
		PropertySources{ "UnitsOfUserData"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 UnitsOfUserData;
};
	[abstract, Description( "Capabilities and management of memory-related logical "
				"devices."): ToSubclass, 
		Locale( 1033), UUID( "{FAF76B64-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_Memory:CIM_StorageExtent
{
		[Description( "An array of octets holding additional error information. An example "
				"is ECC Syndrome or the return of the check bits if a CRC-based error methodology "
				"is used. In the latter case, if a single bit error is recognized and the "
				"CRC algorithm is known, it is possible to determine the exact bit that failed. "
				" This type of data (ECC Syndrome, Check Bit or Parity Bit data, or other "
				"vendor supplied information) is included in this field. If the ErrorInfo "
				"property is equal to 3, \"OK\", then the AdditionalErrorData property has "
				"no meaning."): ToSubclass, DisplayName{ "AdditionalErrorData"}, MappingStrings{ 
		"MIF.DMTF|Memory Device|002.18", "MIF.DMTF|Physical Memory Array|001.13"}: ToSubclass, 
		MAX( 64), PropertySources{ "AdditionalErrorData"}: ToSubclass, read: ToSubclass]
	UINT8 AdditionalErrorData[];
		[Description( "Boolean indicating that the most recent error was correctable. "
				"If the ErrorInfo property is equal to 3, \"OK\", then this property has no "
				"meaning."): ToSubclass, DisplayName{ "CorrectableError"}, MappingStrings{ 
		"MIF.DMTF|Memory Device|002.12", "MIF.DMTF|Physical Memory Array|001.8"}: ToSubclass, 
		PropertySources{ "CorrectableError"}: ToSubclass, read: ToSubclass]
	BOOLEAN CorrectableError;
		[Description( "The ending address, referenced by an application or operating system "
				"and mapped by a memory controller, for this memory object. The ending address "
				"is specified in KBytes."): ToSubclass, DisplayName{ "EndingAddress"}, MappingStrings{ 
		"MIF.DMTF|Memory Array Mapped Addresses|001.4", "MIF.DMTF|Memory Device Mapped "
				"Addresses|001.5"}: ToSubclass, PropertySources{ "EndingAddress"}: ToSubclass, 
		read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT64 EndingAddress;
		[Description( "An integer enumeration indicating the memory access operation that "
				"caused the last error. The type of error is described by the ErrorInfo property. "
				"If the ErrorInfo property is equal to 3, \"OK\", then this property has no "
				"meaning."): ToSubclass, DisplayName{ "ErrorAccess"}, MappingStrings{ "MIF.DMTF|Memory "
				"Device|002.15", "MIF.DMTF|Physical Memory Array|001.10"}: ToSubclass, PropertySources{ 
		"ErrorAccess"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: 
		ToSubclass, Values{ "Other", "Unknown", "Read", "Write", "Partial Write"}: ToSubclass]
	UINT16 ErrorAccess;
		[Description( "Specifies the address of the last memory error. The type of error "
				"is described by the ErrorInfo property. If the ErrorInfo property is equal "
				"to 3, \"OK\", then this property has no meaning."): ToSubclass, DisplayName{ 
		"ErrorAddress"}, MappingStrings{ "MIF.DMTF|Memory Device|002.19", "MIF.DMTF|Memory "
				"Device|002.20", "MIF.DMTF|Physical Memory Array|001.14"}: ToSubclass, PropertySources{ 
		"ErrorAddress"}: ToSubclass, read: ToSubclass]
	UINT64 ErrorAddress;
		[ArrayType( "Indexed"): ToSubclass, Description( "Data captured during the last "
				"erroneous memory access. The data occupies the first n octets of the array "
				"necessary to hold the number of bits specified by the ErrorTransferSize property. "
				"If ErrorTransferSize is 0, then this property has no meaning."): ToSubclass, 
		DisplayName{ "ErrorData"}, MappingStrings{ "MIF.DMTF|Memory Device|002.17", "MIF.DMTF|Physical "
				"Memory Array|001.12"}: ToSubclass, MAX( 64), PropertySources{ "ErrorData"}: 
		ToSubclass, read: ToSubclass]
	UINT8 ErrorData[];
		[Description( "The ordering for data stored in the ErrorData property. \"Least "
				"Significant Byte First\" (value=1) or \"Most Significant Byte First\" (2) "
				"can be specified. If ErrorTransferSize is 0, then this property has no meaning."): 
		ToSubclass, DisplayName{ "ErrorDataOrder"}, PropertySources{ "ErrorDataOrder"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Least Significant Byte First", 
		"Most Significant Byte First"}: ToSubclass]
	UINT16 ErrorDataOrder;
		[Description( "An integer enumeration describing the type of error that occurred "
				"most recently. For example, single (value=6) or double bit errors (7) can "
				"be specified using this property. The values, 12-14, are undefined in the "
				"CIM Schema since in DMI, they mix the semantics of the type of error and "
				"whether it was correctable or not.  The latter is indicated in the property, "
				"CorrectableError."): ToSubclass, DisplayName{ "ErrorInfo"}, MappingStrings{ 
		"MIF.DMTF|Memory Device|002.12", "MIF.DMTF|Physical Memory Array|001.8"}: ToSubclass, 
		ModelCorrespondence{ "CIM_Memory.OtherErrorDescription"}: ToSubclass, PropertySources{ 
		"ErrorInfo"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", 
		"6", "7", "8", "9", "10", "11", "12", "13", "14"}: ToSubclass, Values{ "Other", 
		"Unknown", "OK", "Bad Read", "Parity Error", "Single-Bit Error", "Double-Bit "
				"Error", "Multi-Bit Error", "Nibble Error", "Checksum Error", "CRC Error", 
		"Undefined", "Undefined", "Undefined"}: ToSubclass]
	UINT16 ErrorInfo;
		[Description( "ErrorMethodology for CIM_Memory is a string property that indicates "
				"whether parity or CRC algorithms, ECC or other mechanisms are used. Details "
				"on the algorithm can also be supplied."): ToSubclass, DisplayName{ "ErrorMethodology"}, 
		MappingStrings{ "MIF.DMTF|Physical Memory Array|001.7"}: ToSubclass, Override( 
		"ErrorMethodology"), PropertySources{ "ErrorMethodology"}: ToSubclass, read: 
		ToSubclass]
	STRING ErrorMethodology;
		[Description( "Specifies the range, in bytes, to which the last error can be resolved. "
				"For example, if error addresses are resolved to bit 11 (i.e., on a typical "
				"page basis), then errors can be resolved to 4K boundaries and this property "
				"is set to 4000. If the ErrorInfo property is equal to 3, \"OK\", then this "
				"property has no meaning."): ToSubclass, DisplayName{ "ErrorResolution"}, 
		MappingStrings{ "MIF.DMTF|Memory Device|002.21", "MIF.DMTF|Physical Memory Array|001.15"}: 
		ToSubclass, PropertySources{ "ErrorResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Bytes"): ToSubclass]
	UINT64 ErrorResolution;
		[Description( "The time that the last memory error occurred. The type of error "
				"is described by the ErrorInfo property. If the ErrorInfo property is equal "
				"to 3, \"OK\", then this property has no meaning."): ToSubclass, DisplayName{ 
		"ErrorTime"}, PropertySources{ "ErrorTime"}: ToSubclass, read: ToSubclass]
	DATETIME ErrorTime;
		[Description( "The size of the data transfer in bits that caused the last error. "
				"0 indicates no error. If the ErrorInfo property is equal to 3, \"OK\", then "
				"this property should be set to 0."): ToSubclass, DisplayName{ "ErrorTransferSize"}, 
		MappingStrings{ "MIF.DMTF|Memory Device|002.16", "MIF.DMTF|Physical Memory Array|001.11"}: 
		ToSubclass, PropertySources{ "ErrorTransferSize"}: ToSubclass, read: ToSubclass, 
		Units( "Bits"): ToSubclass]
	UINT32 ErrorTransferSize;
		[Description( "Free form string providing more information if the ErrorType property "
				"is set to 1, \"Other\". If not set to 1, this string has no meaning."): ToSubclass, 
		DisplayName{ "OtherErrorDescription"}, ModelCorrespondence{ "CIM_Memory.ErrorInfo"}: 
		ToSubclass, PropertySources{ "OtherErrorDescription"}: ToSubclass, read: ToSubclass]
	STRING OtherErrorDescription;
		[Description( "The beginning address, referenced by an application or operating "
				"system and mapped by a memory controller, for this memory object. The starting "
				"address is specified in KBytes."): ToSubclass, DisplayName{ "StartingAddress"}, 
		MappingStrings{ "MIF.DMTF|Memory Array Mapped Addresses|001.3", "MIF.DMTF|Memory "
				"Device Mapped Addresses|001.4"}: ToSubclass, PropertySources{ "StartingAddress"}: 
		ToSubclass, read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT64 StartingAddress;
		[Description( "Boolean indicating whether the address information in the property, "
				"ErrorAddress, is a system-level address (TRUE) or a physical address (FALSE). "
				"If the ErrorInfo property is equal to 3, \"OK\", then this property has no "
				"meaning."): ToSubclass, DisplayName{ "SystemLevelAddress"}, PropertySources{ 
		"SystemLevelAddress"}: ToSubclass, read: ToSubclass]
	BOOLEAN SystemLevelAddress;
};
	[Description( "Capabilities and management of cache memory. Cache memory is dedicated "
				"or allocated RAM that a Processor searches first for data, before going to "
				"'regular' memory. CacheMemory is used to speed up the delivery of data to "
				"a Processor. It is usually described by its closeness to the Processor (for "
				"example, Primary or Secondary Cache).\\nIf a DiskDrive includes RAM allocated "
				"for holding the disk's most recently read and/or adjacent data (in order "
				"to speed up retrieval), this also would be modeled as CacheMemory. Note that "
				"CacheMemory is NOT operating system or application level buffers but actual "
				"RAM allocated for caching data for a Processor, from a hard disk, etc."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{FAF76B65-798C-11D2-AAD1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_CacheMemory"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_CacheMemory:CIM_Memory
{
		[Description( "An integer enumeration defining the system cache associativity. "
				"For example, 6 indicates a fully associative cache."): ToSubclass, DisplayName{ 
		"Associativity"}, MappingStrings{ "MIF.DMTF|System Cache|003.15"}: ToSubclass, 
		PropertySources{ "Associativity"}: ToSubclass, read: ToSubclass, ValueMap{ "1", 
		"2", "3", "4", "5", "6", "7", "8"}: ToSubclass, Values{ "Other", "Unknown", "Direct "
				"Mapped", "2-way Set-Associative", "4-way Set-Associative", "Fully Associative", 
		"8-way Set-Associative", "16-way Set-Associative"}: ToSubclass]
	UINT16 Associativity;
		[Description( "Defines whether this is for instruction caching (value=3), data "
				"caching (value=4) or both (value=5, \"Unified\"). Also, \"Other\" (1) and "
				"\"Unknown\" (2) can be defined."): ToSubclass, DisplayName{ "CacheType"}, 
		MappingStrings{ "MIF.DMTF|System Cache|003.9"}: ToSubclass, PropertySources{ 
		"CacheType"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: 
		ToSubclass, Values{ "Other", "Unknown", "Instruction", "Data", "Unified"}: ToSubclass]
	UINT16 CacheType;
		[Description( "Maximum amount of time, in seconds, dirty lines or buckets may "
				"remain in the cache before they are flushed. A value of zero indicated that "
				"a cache flush is not controlled by a flushing timer."): ToSubclass, DisplayName{ 
		"FlushTimer"}, MappingStrings{ "MIF.DMTF|System Cache|003.14"}: ToSubclass, PropertySources{ 
		"FlushTimer"}: ToSubclass, read: ToSubclass, Units( "Seconds"): ToSubclass]
	UINT32 FlushTimer;
		[Description( "Defines whether this is the primary (value=3), secondary (value=4) "
				"or tertiary (value=5) cache. Also, \"Other\" (1), \"Unknown\" (2) and \"Not "
				"Applicable\" (6) can be defined."): ToSubclass, DisplayName{ "Level"}, MappingStrings{ 
		"MIF.DMTF|System Cache|003.2"}: ToSubclass, PropertySources{ "Level"}: ToSubclass, 
		read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6"}: ToSubclass, Values{ 
		"Other", "Unknown", "Primary", "Secondary", "Tertiary", "Not Applicable"}: ToSubclass]
	UINT16 Level;
		[Description( "Size, in bytes, of a single cache bucket or line."): ToSubclass, 
		DisplayName{ "LineSize"}, MappingStrings{ "MIF.DMTF|System Cache|003.10"}: ToSubclass, 
		PropertySources{ "LineSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT32 LineSize;
		[Description( "Policy that shall be employed by the cache for handling read requests. "
				"For example, \"Read\", \"Read-Ahead\" or both can be specified using the "
				"values, 3, 4 or 5, respectively. If the read policy is determined individually "
				"(ie, for each request), then the value 6 (\"Determination per I/O\") should "
				"be specified. \"Other\" (1) and \"Unknown\" (2) are also valid values."): 
		ToSubclass, DisplayName{ "ReadPolicy"}, MappingStrings{ "MIF.DMTF|System Cache|003.13"}: 
		ToSubclass, PropertySources{ "ReadPolicy"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5", "6"}: ToSubclass, Values{ "Other", "Unknown", "Read", 
		"Read-Ahead", "Read and Read-Ahead", "Determination Per I/O"}: ToSubclass]
	UINT16 ReadPolicy;
		[Description( "An integer enumeration describing the algorithm to determine which "
				"cache lines or buckets should be re-used."): ToSubclass, DisplayName{ "ReplacementPolicy"}, 
		MappingStrings{ "MIF.DMTF|System Cache|003.12"}: ToSubclass, PropertySources{ 
		"ReplacementPolicy"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", 
		"4", "5", "6", "7", "8"}: ToSubclass, Values{ "Other", "Unknown", "Least Recently "
				"Used (LRU)", "First In First Out (FIFO)", "Last In First Out (LIFO)", "Least "
				"Frequently Used (LFU)", "Most Frequently Used (MFU)", "Data Dependent Multiple "
				"Algorithms"}: ToSubclass]
	UINT16 ReplacementPolicy;
		[Description( "Defines whether this is write-back (value=3) or write-through (value=4) "
				"Cache, or whether this information \"Varies with Address\" (5) or is defined "
				"individually for each I/O (6). Also, \"Other\" (1) and \"Unknown\" (2) can "
				"be specified."): ToSubclass, DisplayName{ "WritePolicy"}, MappingStrings{ 
		"MIF.DMTF|System Cache|003.5"}: ToSubclass, PropertySources{ "WritePolicy"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6"}: ToSubclass, 
		Values{ "Other", "Unknown", "Write Back", "Write Through", "Varies with Address", 
		"Determination Per I/O"}: ToSubclass]
	UINT16 WritePolicy;
};
	[abstract, Description( "Capabilities and management of NV Storage. Non-volatile "
				"memory natively includes flash and ROM storage. In addition, NV memory can "
				"be BasedOn VolatileStorage, if the volatile memory is backed by a Battery. "
				"This scenario would be completely described by an instance of the AssociatedBattery "
				"relationship, referencing the NonVolatileStorage as the Dependent and the "
				"Battery as the Antecedent, and an instance of the BasedOn relationship, referencing "
				"the NonVolatileStorage as the Dependent and the VolatileStorage as the Antecedent."): 
		ToSubclass, Locale( 
		1033), UUID( "{18074AFA-F0FE-11d2-8617-0000F8102E5F}"): ToInstance]
class CIM_NonVolatileStorage:CIM_Memory
{
		[Description( "Indicating that the NV storage is writeable."): ToSubclass, DisplayName{ 
		"IsWriteable"}, PropertySources{ "IsWriteable"}: ToSubclass, read: ToSubclass]
	BOOLEAN IsWriteable;
};
	[abstract, Description( "Capabilities and management of volatile storage."): ToSubclass, 
		Locale( 1033), UUID( 
		"{36851DFE-F0FE-11d2-8617-0000F8102E5F}"): ToInstance]
class CIM_VolatileStorage:CIM_Memory
{
		[Description( "Indicates whether this memory can be cached or not."): ToSubclass, 
		DisplayName{ "Cacheable"}, MappingStrings{ "MIF.DMTF|System Resource Memory Info|001.5"}: 
		ToSubclass, PropertySources{ "Cacheable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Cacheable;
		[Description( "An enumeration indicating the cache type that is compatible with "
				"this memory. For example, 4 indicates write-through cache.  If the Cacheable "
				"property is set to false, then this property does not have meaning and should "
				"be set to 5, \"Not Applicable\"."): ToSubclass, DisplayName{ "CacheType"}, 
		MappingStrings{ "MIF.DMTF|System Resource Memory Info|001.6"}: ToSubclass, PropertySources{ 
		"CacheType"}: ToSubclass, read: ToSubclass, Values{ "Other", "Unknown", "Write-Back", 
		"Write-Through", "Not Applicable"}: ToSubclass]
	UINT16 CacheType;
};
	[abstract, Description( "CIM_ProtectedSpaceExtent define addressable logical block "
				"addresses, treated as a single storage extent, located on a single physical "
				"extent.  Protected space extents exclude any logical blocks mapped as check "
				"data and contain user data stripe depth mapping information. An alternate "
				"possibility, if automatic configuration is used, is to instantiate or extend "
				"the CIM_AggregatePSExtent class."): ToSubclass, Locale( 1033), 
				UUID( "{35E25AA4-E3D1-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ProtectedSpaceExtent:CIM_StorageExtent
{
		[Description( "For a ProtectedSpaceExtent that is allocated to a VolumeSet, (i.e. "
				"is named in a CIM_VolumeSetBasedOnPSExtent association), this property is "
				"the number of user data bytes placed on this ProtectedSpaceExtent before "
				"moving on to the next ProtectedSpaceExtent in the VolumeSet.  Otherwise, "
				"this ProtectedSpaceExtent is considered to be unallocated and this property "
				"shall be set to zero (0h.)"): ToSubclass, DisplayName{ "UserDataStripeDepth"}, 
		MappingStrings{ "MIF.DMTF|Protected Space Extent|001.6"}: ToSubclass, PropertySources{ 
		"UserDataStripeDepth"}: ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 UserDataStripeDepth;
};
	[Description( "A DiskPartition is a presentation of a contiguous range of logical "
				"blocks that is identifiable by the OperatingSystem via the Partition's type "
				"and subtype fields. DiskPartitions should be directly realized by PhysicalMedia "
				"(indicated by the RealizesDiskPartition association) or built on StorageVolumes "
				"(indicated by the PartitionBasedOnVolume association."): ToSubclass, dynamic: ToInstance, 
				Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C541-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_DiskPartition"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DiskPartition:CIM_StorageExtent
{
		[Description( "Boolean indicating that the DiskPartition is labelled as bootable. "
				"This does not mean that an OperatingSystem is actually loaded on the partition."): 
		ToSubclass, DisplayName{ "Bootable"}, PropertySources{ "Bootable"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN Bootable;
		[Description( "Boolean indicating that the DiskPartition is labelled as the primary "
				"partition for a ComputerSystem."): ToSubclass, DisplayName{ "PrimaryPartition"}, 
		PropertySources{ "PrimaryPartition"}: ToSubclass, read: ToSubclass]
	BOOLEAN PrimaryPartition;
};
	[abstract, Description( "CIM_AggregatePSExtent defines the number of addressable "
				"logical blocks on a single storage device, excluding any logical blocks mapped "
				"as check data. These logical blocks are contained within a single volume "
				"set (if volume sets are defined). This is an alternative grouping for CIM_ProtectedSpaceExtent, "
				"when only summary information is needed or when automatic configuration is "
				"used. Automatic configuration can result in thousands of CIM_ProtectedSpaceExtent "
				"being defined. There is no value in modeling the individual extents.  So, "
				"the CIM_AggregatePSExtent object was defined."): ToSubclass, Locale( 1033), 
				UUID( "{2D0E255C-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_AggregatePSExtent:CIM_StorageExtent
{
};
	[Description( "Capabilities and management of the Printer LogicalDevice."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C54A-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Printer"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Printer:CIM_LogicalDevice
{
		[Description( "Describes all of the job sheets that are available on the Printer. "
				"This can also be used to describe the banner that a Printer might provide "
				"at the beginning of each Job, or can describe other user specified options."): 
		ToSubclass, DisplayName{ "AvailableJobSheets"}, ModelCorrespondence{ "CIM_PrintJob.RequiredJobSheets"}: 
		ToSubclass, PropertySources{ "AvailableJobSheets"}: ToSubclass, read: ToSubclass]
	STRING AvailableJobSheets[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of integers indicating "
				"Printer capabilities. Information such as \"Duplex Printing\" (value=3) or "
				"\"Transparency Printing\" (7) is specified in this property."): ToSubclass, 
		DisplayName{ "Capabilities"}, ModelCorrespondence{ "CIM_Printer.CapabilityDescriptions", 
		"CIM_PrintJob.Finishing", "CIM_PrintService.Capabilities"}: ToSubclass, PropertySources{ 
		"Capabilities"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Color "
				"Printing", "Duplex Printing", "Copies", "Collation", "Stapling", "Transparency "
				"Printing", "Punch", "Cover", "Bind", "Black and White Printing", "One Sided", 
		"Two Sided Long Edge", "Two Sided Short Edge", "Portrait", "Landscape", "Reverse "
				"Portrait", "Reverse Landscape", "Quality High", "Quality Normal", "Quality "
				"Low"}: ToSubclass]
	UINT16 Capabilities[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the Printer features indicated "
				"in the Capabilities array. Note, each entry of this array is related to the "
				"entry in the Capabilities array that is located at the same index."): ToSubclass, 
		DisplayName{ "CapabilityDescriptions"}, ModelCorrespondence{ "CIM_Printer.Capabilities"}: 
		ToSubclass, PropertySources{ "CapabilityDescriptions"}: ToSubclass, read: ToSubclass]
	STRING CapabilityDescriptions[];
		[ArrayType( "Indexed"): ToSubclass, Description( "Identifies the available character "
				"sets for the output of text related to managing the Printer. Strings provided "
				"in this property should conform to the semantics and syntax specified by "
				"section 4.1.2 (\"Charset parameter\") in RFC 2046 (MIME Part 2) and contained "
				"in the IANA character-set registry. Examples include \"utf-8\", \"us-ascii\" "
				"and \"iso-8859-1\"."): ToSubclass, DisplayName{ "CharSetsSupported"}, MappingStrings{ 
		"MIB.IETF|Printer-MIB.prtLocalizationCharacterSet"}: ToSubclass, ModelCorrespondence{ 
		"CIM_PrintJob.CharSet"}: ToSubclass, PropertySources{ "CharSetsSupported"}: ToSubclass, 
		read: ToSubclass]
	STRING CharSetsSupported[];
		[Description( "Specifies which finishings and other capabilities of the Printer "
				"are currently being used. An entry in this property should also be listed "
				"in the Capabilities array."): ToSubclass, DisplayName{ "CurrentCapabilities"}, 
		ModelCorrespondence{ "CIM_Printer.Capabilities"}: ToSubclass, PropertySources{ 
		"CurrentCapabilities"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Color Printing", "Duplex Printing", "Copies", "Collation", "Stapling", "Transparency "
				"Printing", "Punch", "Cover", "Bind", "Black and White Printing", "One Sided", 
		"Two Sided Long Edge", "Two Sided Short Edge", "Portrait", "Landscape", "Reverse "
				"Portrait", "Reverse Landscape", "Quality High", "Quality Normal", "Quality "
				"Low"}: ToSubclass]
	UINT16 CurrentCapabilities[];
		[Description( "Specifies the current character set being used for the output of "
				"text relating to management of the Printer. The character set described by "
				"this property should also be listed in CharsetsSupported. The string specified "
				"by this property should conform to the semantics and syntax specified by "
				"section 4.1.2 (\"Charset parameter\") in RFC 2046 (MIME Part 2) and contained "
				"in the IANA character-set registry. Examples include \"utf-8\", \"us-ascii\" "
				"and \"iso-8859-1\"."): ToSubclass, DisplayName{ "CurrentCharSet"}, ModelCorrespondence{ 
		"CIM_Printer.CharSetsSupported"}: ToSubclass, PropertySources{ "CurrentCharSet"}: 
		ToSubclass, read: ToSubclass]
	STRING CurrentCharSet;
		[Description( "Indicates the current printer language being used. A language that "
				"is being used by the Printer should also be listed in LanguagesSupported."): 
		ToSubclass, DisplayName{ "CurrentLanguage"}, ModelCorrespondence{ "CIM_Printer.LanguagesSupported", 
		"CIM_Printer.CurrentMimeType"}: ToSubclass, PropertySources{ "CurrentLanguage"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", 
		"9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", 
		"22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", 
		"35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47"}: 
		ToSubclass, Values{ "Other", "Unknown", "PCL", "HPGL", "PJL", "PS", "PSPrinter", 
		"IPDS", "PPDS", "EscapeP", "Epson", "DDIF", "Interpress", "ISO6429", "Line Data", 
		"MODCA", "REGIS", "SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE", 
		"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL", "Simple Text", "NPAP", "DOC", 
		"imPress", "Pinwriter", "NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF", 
		"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"}: ToSubclass]
	UINT16 CurrentLanguage;
		[Description( "Specifies the mime type currently being used by the Printer if "
				"the CurrentLanguage is set to indicate a mime type is in use (value = 47)."): 
		ToSubclass, DisplayName{ "CurrentMimeType"}, ModelCorrespondence{ "CIM_Printer.CurrentLanguage"}: 
		ToSubclass, PropertySources{ "CurrentMimeType"}: ToSubclass, read: ToSubclass]
	STRING CurrentMimeType;
		[Description( "Identifies the current language being used by the Printer for management. "
				"The language listed in the CurrentNaturalLanguage property should also be "
				"listed in NaturalLanguagesSupported."): ToSubclass, DisplayName{ "CurrentNaturalLanguage"}, 
		ModelCorrespondence{ "CIM_Printer.NaturalLanguagesSupported"}: ToSubclass, PropertySources{ 
		"CurrentNaturalLanguage"}: ToSubclass, read: ToSubclass]
	STRING CurrentNaturalLanguage;
		[Description( "Specifies the paper type that the Printer is currently using. The "
				"string should be expressed in the form specified by ISO/IEC 10175 Document "
				"Printing Application (DPA) which is also summarized in Appendix C of RFC "
				"1759 (Printer MIB)."): ToSubclass, DisplayName{ "CurrentPaperType"}, ModelCorrespondence{ 
		"CIM_Printer.PaperTypesAvailable"}: ToSubclass, PropertySources{ "CurrentPaperType"}: 
		ToSubclass, read: ToSubclass]
	STRING CurrentPaperType;
		[Description( "Specifies which finishings and other capabilities of the Printer "
				"will be used by default. An entry in DefaultCapabilities should also be listed "
				"in the Capabilities array."): ToSubclass, DisplayName{ "DefaultCapabilities"}, 
		ModelCorrespondence{ "CIM_Printer.Capabilities"}: ToSubclass, PropertySources{ 
		"DefaultCapabilities"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Color Printing", "Duplex Printing", "Copies", "Collation", "Stapling", "Transparency "
				"Printing", "Punch", "Cover", "Bind", "Black and White Printing", "One Sided", 
		"Two Sided Long Edge", "Two Sided Short Edge", "Portrait", "Landscape", "Reverse "
				"Portrait", "Reverse Landscape", "Quality High", "Quality Normal", "Quality "
				"Low"}: ToSubclass]
	UINT16 DefaultCapabilities[];
		[Description( "The number of copies that will be produced for a single Job unless "
				"otherwise specified."): ToSubclass, DisplayName{ "DefaultCopies"}, PropertySources{ 
		"DefaultCopies"}: ToSubclass, read: ToSubclass]
	UINT32 DefaultCopies;
		[Description( "Indicates the default printer language. A language that is used "
				"as a default by the Printer should also be listed in LanguagesSupported."): 
		ToSubclass, DisplayName{ "DefaultLanguage"}, ModelCorrespondence{ "CIM_Printer.LanguagesSupported", 
		"CIM_Printer.DefaultMimeType"}: ToSubclass, PropertySources{ "DefaultLanguage"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", 
		"9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", 
		"22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", 
		"35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47"}: 
		ToSubclass, Values{ "Other", "Unknown", "PCL", "HPGL", "PJL", "PS", "PSPrinter", 
		"IPDS", "PPDS", "EscapeP", "Epson", "DDIF", "Interpress", "ISO6429", "Line Data", 
		"MODCA", "REGIS", "SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE", 
		"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL", "Simple Text", "NPAP", "DOC", 
		"imPress", "Pinwriter", "NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF", 
		"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"}: ToSubclass]
	UINT16 DefaultLanguage;
		[Description( "Specifies the default mime type used by the Printer if the DefaultLanguage "
				"is set to indicate a mime type is in use (value=47)."): ToSubclass, DisplayName{ 
		"DefaultMimeType"}, ModelCorrespondence{ "CIM_Printer.DefaultLanguage"}: ToSubclass, 
		PropertySources{ "DefaultMimeType"}: ToSubclass, read: ToSubclass]
	STRING DefaultMimeType;
		[Description( "The number of print-stream pages that the Printer will render onto "
				"a single media sheet unless a Job specifies otherwise."): ToSubclass, DisplayName{ 
		"DefaultNumberUp"}, PropertySources{ "DefaultNumberUp"}: ToSubclass, read: ToSubclass]
	UINT32 DefaultNumberUp;
		[Description( "Specifies the paper type that the Printer will use if a PrintJob "
				"does not specify a particular type. The string should be expressed in the "
				"form specified by ISO/IEC 10175 Document Printing Application (DPA) which "
				"is also summarized in Appendix C of RFC 1759 (Printer MIB)."): ToSubclass, 
		DisplayName{ "DefaultPaperType"}, ModelCorrespondence{ "CIM_Printer.PaperTypesAvailable"}: 
		ToSubclass, PropertySources{ "DefaultPaperType"}: ToSubclass, read: ToSubclass]
	STRING DefaultPaperType;
		[Description( "Printer error information."): ToSubclass, DisplayName{ "DetectedErrorState"}, 
		MappingStrings{ "MIB.IETF|Printer-MIB.hrPrinterDetectedErrorState"}: ToSubclass, 
		ModelCorrespondence{ "CIM_Printer.ErrorInformation"}: ToSubclass, PropertySources{ 
		"DetectedErrorState"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"No Error", "Low Paper", "No Paper", "Low Toner", "No Toner", "Door Open", "Jammed", 
		"Offline", "Service Requested", "Output Bin Full"}: ToSubclass]
	UINT16 DetectedErrorState;
		[Description( "An array providing supplemental information for the current error "
				"state, indicated in DetectedErrorState."): ToSubclass, DisplayName{ "ErrorInformation"}, 
		ModelCorrespondence{ "CIM_Printer.DetectedErrorState"}: ToSubclass, PropertySources{ 
		"ErrorInformation"}: ToSubclass, read: ToSubclass, write: ToSubclass]
	STRING ErrorInformation[];
		[Description( "Printer's horizontal resolution in Pixels per Inch."): ToSubclass, 
		DisplayName{ "HorizontalResolution"}, ModelCorrespondence{ "CIM_PrintJob.HorizontalResolution"}: 
		ToSubclass, PropertySources{ "HorizontalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels per Inch"): ToSubclass]
	UINT32 HorizontalResolution;
		[Counter, Description( "Printer jobs processed since last reset.  These jobs may "
				"be processed from one or more PrintQueues."): ToSubclass, DisplayName{ "JobCountSinceLastReset"}, 
		PropertySources{ "JobCountSinceLastReset"}: ToSubclass, read: ToSubclass]
	UINT32 JobCountSinceLastReset;
		[Description( "An array indicating the print languages natively supported."): 
		ToSubclass, DisplayName{ "LanguagesSupported"}, MappingStrings{ "MIB.IETF|Printer-MIB.prtInterpreterLangFamily"}: 
		ToSubclass, ModelCorrespondence{ "CIM_Printer.MimeTypesSupported", "CIM_PrintJob.Language", 
		"CIM_PrintService.LanguagesSupported"}: ToSubclass, PropertySources{ "LanguagesSupported"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", 
		"9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", 
		"22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", 
		"35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47"}: 
		ToSubclass, Values{ "Other", "Unknown", "PCL", "HPGL", "PJL", "PS", "PSPrinter", 
		"IPDS", "PPDS", "EscapeP", "Epson", "DDIF", "Interpress", "ISO6429", "Line Data", 
		"MODCA", "REGIS", "SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE", 
		"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL", "Simple Text", "NPAP", "DOC", 
		"imPress", "Pinwriter", "NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF", 
		"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"}: ToSubclass]
	UINT16 LanguagesSupported[];
		[Description( "Specifies the marking technology used by the Printer."): ToSubclass, 
		DisplayName{ "MarkingTechnology"}, MappingStrings{ "MIB.IETF|Printer-MIB.prtMarkerMarkTech"}: 
		ToSubclass, PropertySources{ "MarkingTechnology"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", 
		"14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", 
		"27"}: ToSubclass, Values{ "Other", "Unknown", "Electrophotographic LED", "Electrophotographic "
				"Laser", "Electrophotographic Other", "Impact Moving Head Dot Matrix 9pin", 
		"Impact Moving Head Dot Matrix 24pin", "Impact Moving Head Dot Matrix Other", 
		"Impact Moving Head Fully Formed", "Impact Band", "Impact Other", "Inkjet Aqueous", 
		"Inkjet Solid", "Inkjet Other", "Pen", "Thermal Transfer", "Thermal Sensitive", 
		"Thermal Diffusion", "Thermal Other", "Electroerosion", "Electrostatic", "Photographic "
				"Microfiche", "Photographic Imagesetter", "Photographic Other", "Ion Deposition", 
		"eBeam", "Typesetter"}: ToSubclass]
	UINT16 MarkingTechnology;
		[Description( "The maximum number of copies that can be produced by the Printer "
				"from a single Job."): ToSubclass, DisplayName{ "MaxCopies"}, ModelCorrespondence{ 
		"CIM_PrintJob.Copies"}: ToSubclass, PropertySources{ "MaxCopies"}: ToSubclass, 
		read: ToSubclass]
	UINT32 MaxCopies;
		[Description( "The maximum number of print-stream pages that the Printer can render "
				"onto a single media sheet."): ToSubclass, DisplayName{ "MaxNumberUp"}, ModelCorrespondence{ 
		"CIM_PrintJob.NumberUp"}: ToSubclass, PropertySources{ "MaxNumberUp"}: ToSubclass, 
		read: ToSubclass]
	UINT32 MaxNumberUp;
		[Description( "Specifies the largest Job (as a byte stream) that the Printer will "
				"accept in units of Kbytes. A value of zero indicates that no limit has been "
				"set."): ToSubclass, DisplayName{ "MaxSizeSupported"}, ModelCorrespondence{ 
		"CIM_PrintJob.JobSize"}: ToSubclass, PropertySources{ "MaxSizeSupported"}: ToSubclass, 
		read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT32 MaxSizeSupported;
		[Description( "An array of free-form strings providing more detailed explanations "
				"of any mime types that are supported by the Printer. If data is provided "
				"for this property, then the value 47, \"Mime\", should be included in the "
				"LanguagesSupported property."): ToSubclass, DisplayName{ "MimeTypesSupported"}, 
		ModelCorrespondence{ "CIM_Printer.LanguagesSupported", "CIM_PrintJob.MimeTypes", 
		"CIM_PrintService.MimeTypesSupported"}: ToSubclass, PropertySources{ "MimeTypesSupported"}: 
		ToSubclass, read: ToSubclass]
	STRING MimeTypesSupported[];
		[ArrayType( "Indexed"): ToSubclass, Description( "Identifies the available languages "
				"for strings used by the Printer for the output of management information. "
				"The strings should conform to RFC 1766, for example \"en\" is used for English."): 
		ToSubclass, DisplayName{ "NaturalLanguagesSupported"}, MappingStrings{ "MIB.IETF|Printer-MIB.prtLocalizationLanguage"}: 
		ToSubclass, ModelCorrespondence{ "CIM_PrintJob.NaturalLanguage"}: ToSubclass, 
		PropertySources{ "NaturalLanguagesSupported"}: ToSubclass, read: ToSubclass]
	STRING NaturalLanguagesSupported[];
		[Description( "An integer array indicating the types of paper supported."): ToSubclass, 
		DisplayName{ "PaperSizesSupported"}, PropertySources{ "PaperSizesSupported"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "A", "B", "C", "D", 
		"E", "Letter", "Legal", "NA-10x13-Envelope", "NA-9x12-Envelope", "NA-Number-10-Envelope", 
		"NA-7x9-Envelope", "NA-9x11-Envelope", "NA-10x14-Envelope", "NA-Number-9-Envelope", 
		"NA-6x9-Envelope", "NA-10x15-Envelope", "A0", "A1", "A2", "A3", "A4", "A5", "A6", 
		"A7", "A8", "A9A10", "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", 
		"B10", "C0", "C1", "C2C3", "C4", "C5", "C6", "C7", "C8", "ISO-Designated", "JIS "
				"B0", "JIS B1", "JIS B2", "JIS B3", "JIS B4", "JIS B5", "JIS B6", "JIS B7", 
		"JIS B8", "JIS B9", "JIS B10", "NA-Letter", "NA-Legal", "B4-Envelope", "B5-Envelope", 
		"C3-Envelope", "C4-Envelope", "C5-Envelope", "C6-Envelope", "Designated-Long-Envelope", 
		"Monarch-Envelope", "Executive", "Folio", "Invoice", "Ledger", "Quarto"}: ToSubclass]
	UINT16 PaperSizesSupported[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"specifying the types of paper that are currently available on the Printer. "
				"Each string should be expressed in the form specified by ISO/IEC 10175 Document "
				"Printing Application (DPA) which is also summarized in Appendix C of RFC "
				"1759 (Printer MIB). Examples of valid strings are \"iso-a4-colored\" and "
				"\"na-10x14-envelope\". By definition a paper size that is available and listed "
				"in PaperTypesAvailable should also appear in the PaperSizesSupported property."): 
		ToSubclass, DisplayName{ "PaperTypesAvailable"}, MappingStrings{ "MIB.IETF|Printer-MIB.prtInputMediaName"}: 
		ToSubclass, ModelCorrespondence{ "CIM_PrintJob.RequiredPaperType", "CIM_PrintService.PaperTypesAvailable"}: 
		ToSubclass, PropertySources{ "PaperTypesAvailable"}: ToSubclass, read: ToSubclass]
	STRING PaperTypesAvailable[];
		[Description( "Status information for a Printer, beyond that specified in the "
				"LogicalDevice Availability property. Values include \"Idle\" (3) and an indication "
				"that the Device is currently printing (4)."): ToSubclass, DisplayName{ "PrinterStatus"}, 
		MappingStrings{ "MIB.IETF|Printer-MIB.hrPrinterStatus"}: ToSubclass, PropertySources{ 
		"PrinterStatus"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5", "6", "7"}: ToSubclass, Values{ "Other", "Unknown", "Idle", "Printing", "Warmup", 
		"Stopped Printing", "Offline"}: ToSubclass]
	UINT16 PrinterStatus;
		[Description( "Time of last reset of the Printer Device."): ToSubclass, DisplayName{ 
		"TimeOfLastReset"}, PropertySources{ "TimeOfLastReset"}: ToSubclass, read: ToSubclass]
	DATETIME TimeOfLastReset;
		[Description( "Printer's vertical resolution in Pixels per Inch."): ToSubclass, 
		DisplayName{ "VerticalResolution"}, ModelCorrespondence{ "CIM_PrintJob.HorizontalResolution"}: 
		ToSubclass, PropertySources{ "VerticalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels per Inch"): ToSubclass]
	UINT32 VerticalResolution;
};
	[abstract, Description( "Capabilities and management of cooling devices."): ToSubclass, 
		Locale( 1033), UUID( 
		"{9565979A-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_CoolingDevice:CIM_LogicalDevice
{
		[Description( "ActiveCooling is a boolean indicating that the cooling device provides "
				"active (as opposed to passive) cooling."): ToSubclass, DisplayName{ "ActiveCooling"}, 
		PropertySources{ "ActiveCooling"}: ToSubclass, read: ToSubclass]
	BOOLEAN ActiveCooling;
};
	[Description( "Capabilities and management of a refrigeration cooling device."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{F3A5233A-E3D3-11d2-8601-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_Refrigeration"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Refrigeration:CIM_CoolingDevice
{
};
	[Description( "Capabilities and management of a fan cooling device."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{0A59C856-E3D4-11d2-8601-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Fan"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Fan:CIM_CoolingDevice
{
		[Description( "DesiredSpeed is the currently requested fan speed, defined in revolutions "
				"per minute, when a variable speed fan is supported (VariableSpeed boolean "
				"= TRUE). The current speed is determined via a sensor (CIM_Tachometer) that "
				"is associated with the fan using the CIM_AssociatedSensor relationship."): 
		ToSubclass, DisplayName{ "DesiredSpeed"}, PropertySources{ "DesiredSpeed"}: ToSubclass, 
		read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	UINT64 DesiredSpeed;
		[Description( "Indication of whether the fan supports variable speeds."): ToSubclass, 
		DisplayName{ "VariableSpeed"}, PropertySources{ "VariableSpeed"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN VariableSpeed;
		[Description( "Requests that the fan speed be set to the value specified in the "
				"method's input parameter. The return value should be 0 if the request was "
				"successfully executed, 1 if the request is not supported and some other value "
				"if an error occurred. "): ToSubclass, DisplayName{ "SetSpeed"}, MethodSource{ 
		"SetSpeed"}]
	UINT32 SetSpeed(
	
		[DisplayName{ "DesiredSpeed"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"DesiredSpeed"}: ToSubclass]
			UINT64 DesiredSpeed
	);
};
	[Description( "Capabilities and management of a heat pipe cooling device."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FE5D55E0-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_HeatPipe"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_HeatPipe:CIM_CoolingDevice
{
};
	[abstract, Description( "Capabilities and management of the scanner logical device."): 
		ToSubclass, Locale( 
		1033), UUID( "{07F12A62-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_Scanner:CIM_LogicalDevice
{
};
	[Description( "The POTSModem class represents a Device that translates binary data "
				"into wave modulations for sound based transmission.  It connects to the POTS "
				"(Plain Old Telephone System) network."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C546-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_PotsModem"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PotsModem:CIM_LogicalDevice
{
		[Description( "Answer mode defines the current auto-answer/call-back setting for "
				"the modem."): ToSubclass, DisplayName{ "AnswerMode"}, PropertySources{ "AnswerMode"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Disabled", "Manual "
				"Answer", "Auto Answer", "Auto Answer with Call-Back"}: ToSubclass]
	UINT16 AnswerMode;
		[Description( "Describes the data compression characteristics of the modem."): 
		ToSubclass, DisplayName{ "CompressionInfo"}, PropertySources{ "CompressionInfo"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "No Compression", "MNP "
				"5", "V.42bis"}: ToSubclass]
	UINT16 CompressionInfo;
		[Description( "CountriesSupported is an array (bag) that contains a set of strings "
				"defining the countries/regions in which the modem can operate."): ToSubclass, 
		DisplayName{ "CountriesSupported"}, PropertySources{ "CountriesSupported"}: ToSubclass, 
		read: ToSubclass]
	STRING CountriesSupported[];
		[Description( "CountrySelected is a string value defining the country/region for "
				"which the modem is currently programmed. When multiple countries/regions "
				"are supported, this property defines which one is currently selected for "
				"use."): ToSubclass, DisplayName{ "CountrySelected"}, PropertySources{ "CountrySelected"}: 
		ToSubclass, read: ToSubclass]
	STRING CountrySelected;
		[Description( "CurrentPasswords is an array (bag) containing the currently defined "
				"passwords for the modem. This array may be left blank for security reasons."): 
		ToSubclass, DisplayName{ "CurrentPasswords"}, PropertySources{ "CurrentPasswords"}: 
		ToSubclass, read: ToSubclass]
	STRING CurrentPasswords[];
		[Description( "DialType is an integer indicating whether tone (value=1) or pulse "
				"dialing (value=2) is used. \"Unknown\" (0) can also be defined."): ToSubclass, 
		DisplayName{ "DialType"}, PropertySources{ "DialType"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Tone", "Pulse"}: ToSubclass]
	UINT16 DialType;
		[Description( "Describes the error correction characteristics of the modem."): 
		ToSubclass, DisplayName{ "ErrorControlInfo"}, PropertySources{ "ErrorControlInfo"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "No Error Correction", 
		"MNP 4", "LAPM"}: ToSubclass]
	UINT16 ErrorControlInfo;
		[Description( "InactivityTimeout defines the time limit (in seconds) for automatic "
				"disconnection of the phone line, if no data is exchanged.  A value of 0 indicates "
				"that this feature is present but not enabled."): ToSubclass, DisplayName{ 
		"InactivityTimeout"}, PropertySources{ "InactivityTimeout"}: ToSubclass, read: 
		ToSubclass, Units( "Seconds"): ToSubclass]
	UINT32 InactivityTimeout;
		[Description( "Defines the maximum settable communication speed for accessing "
				"the phone system."): ToSubclass, DisplayName{ "MaxBaudRateToPhone"}, PropertySources{ 
		"MaxBaudRateToPhone"}: ToSubclass, read: ToSubclass, Units( "Bits per second"): 
		ToSubclass]
	UINT32 MaxBaudRateToPhone;
		[Description( "Defines the maximum settable communication speed to the COM port "
				"for an external modem. Enter 0 if not applicable."): ToSubclass, DisplayName{ 
		"MaxBaudRateToSerialPort"}, PropertySources{ "MaxBaudRateToSerialPort"}: ToSubclass, 
		read: ToSubclass, Units( "Bits per second"): ToSubclass]
	UINT32 MaxBaudRateToSerialPort;
		[Description( "MaxNumberOfPasswords specifies the number of passwords definable "
				"in the modem itself. If this feature is not supported, enter 0."): ToSubclass, 
		DisplayName{ "MaxNumberOfPasswords"}, PropertySources{ "MaxNumberOfPasswords"}: 
		ToSubclass, read: ToSubclass]
	UINT16 MaxNumberOfPasswords;
		[Description( "Describes the modulation scheme of the modem."): ToSubclass, DisplayName{ 
		"ModulationScheme"}, PropertySources{ "ModulationScheme"}: ToSubclass, read: 
		ToSubclass, Values{ "Unknown", "Other", "Not Supported", "Bell 103", "Bell 212A", 
		"V.22bis", "V.32", "V.32bis", "V.turbo", "V.FC", "V.34", "V.34bis"}: ToSubclass]
	UINT16 ModulationScheme;
		[Description( "Number of rings before the modem answers an incoming call."): ToSubclass, 
		DisplayName{ "RingsBeforeAnswer"}, PropertySources{ "RingsBeforeAnswer"}: ToSubclass, 
		read: ToSubclass]
	UINT8 RingsBeforeAnswer;
		[Description( "Describes the volume level of the audible tones from the modem. "
				"For example, high, medium or low volume can be reported (values 3, 4 or 5, "
				"respectively)."): ToSubclass, DisplayName{ "SpeakerVolumeInfo"}, PropertySources{ 
		"SpeakerVolumeInfo"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Not Supported", "High", "Medium", "Low", "Off", "Auto"}: ToSubclass]
	UINT16 SpeakerVolumeInfo;
		[Description( "Indication of whether the modem supports call-back"): ToSubclass, 
		DisplayName{ "SupportsCallback"}, PropertySources{ "SupportsCallback"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN SupportsCallback;
		[Description( "Boolean indicating that synchronous, as well as asynchronous, communication "
				"is supported."): ToSubclass, DisplayName{ "SupportsSynchronousConnect"}, 
		PropertySources{ "SupportsSynchronousConnect"}: ToSubclass, read: ToSubclass]
	BOOLEAN SupportsSynchronousConnect;
		[Description( "The TimeOfLastReset property indicates the date and time this controller "
				"was last reset.  This could mean the controller was powered down, or reinitialized."): 
		ToSubclass, DisplayName{ "TimeOfLastReset"}, PropertySources{ "TimeOfLastReset"}: 
		ToSubclass, read: ToSubclass]
	DATETIME TimeOfLastReset;
};
	[Description( "NetworkAdapter is an Abstract class defining general networking "
				"hardware concepts (for example, PermanentAddress or Speed of operation). "
				"NetworkAdapters are Devices with the ability to support multiple, higher "
				"level protocols and provide the implementation behind the Network Model's "
				"ProtocolEndpoint class. (This information is conveyed using the DeviceSAPImplementation "
				"association, defined in the Core Model.) NetworkAdapters and their Endpoints "
				"represent the potential for connectivity among peers./nThe 'potential for "
				"connectivity' is very different than the master-slave/controller-controlled "
				"by relationships of CIM_Controller. Sometimes, however, a single Device is "
				"both a kind of NetworkAdapter and a Controller - for example, when a FibreChannelAdapater "
				"is operating as a ComputerSystem's SCSIController. In this case, there are "
				"aspects of the Device that are network oriented and others that are Controller "
				"oriented - and, both the Controller and Adapter classes should be instantiated. "
				"A DeviceIdentity relationship would also be created to tie together these "
				"differing aspects/abstractions of the Device."): ToSubclass, dynamic: ToInstance, Locale( 1033), 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C532-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_NetworkAdapter"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_NetworkAdapter:CIM_LogicalDevice
{
		[Description( "A boolean indicating whether the NetworkAdapter is capable of automatically "
				"determining the speed or other communications characteristics of the attached "
				"network media."): ToSubclass, DisplayName{ "AutoSense"}, PropertySources{ 
		"AutoSense"}: ToSubclass, read: ToSubclass]
	BOOLEAN AutoSense;
		[Description( "The maximum speed, in bits per second, for the network adapter."): 
		ToSubclass, DisplayName{ "MaxSpeed"}, PropertySources{ "MaxSpeed"}: ToSubclass, 
		read: ToSubclass, Units( "Bits per Second"): ToSubclass]
	UINT64 MaxSpeed;
		[Description( "An array of strings indicating the network addresses for an adapter."): 
		ToSubclass, DisplayName{ "NetworkAddresses"}, MappingStrings{ "MIF.DMTF|Network "
				"Adapter 802 Port|001.3"}: ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ 
		"NetworkAddresses"}: ToSubclass, read: ToSubclass]
	STRING NetworkAddresses[];
		[Description( "PermanentAddress defines the network address hard coded into an "
				"adapter.  This 'hard coded' address may be changed via firmware upgrade or "
				"software configuration. If so, this field should be updated when the change "
				"is made.  PermanentAddress should be left blank if no 'hard coded' address "
				"exists for the network adapter."): ToSubclass, DisplayName{ "PermanentAddress"}, 
		MappingStrings{ "MIF.DMTF|Network Adapter 802 Port|001.2"}: ToSubclass, MaxLen( 
		64): ToSubclass, PropertySources{ "PermanentAddress"}: ToSubclass, read: ToSubclass]
	STRING PermanentAddress;
		[Description( "An estimate of the current bandwidth in bits per second. For endpoints "
				"which vary in bandwidth or for those where no accurate estimation can be "
				"made, this property should contain the nominal bandwidth."): ToSubclass, 
		DisplayName{ "Speed"}, MappingStrings{ "MIB.IETF|RFC1213-MIB.ifSpeed", "MIF.DMTF|Network "
				"Adapter 802 Port|001.5"}: ToSubclass, PropertySources{ "Speed"}: ToSubclass, 
		read: ToSubclass, Units( "Bits per Second"): ToSubclass]
	UINT64 Speed;
};
	[abstract, Description( "User devices are logical devices that allow a computer "
				"system's users to input, view or hear data. The CIM_UserDevice class is a "
				"superclass from which other classes, such as Keyboard or CIM_DesktopMonitor, "
				"descend."): ToSubclass, 
		Locale( 1033), UUID( "{8502C533-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_UserDevice:CIM_LogicalDevice
{
		[Description( "An indication of whether the device is locked, preventing user "
				"input or output."): ToSubclass, DisplayName{ "IsLocked"}, PropertySources{ 
		"IsLocked"}: ToSubclass, read: ToSubclass]
	BOOLEAN IsLocked;
};
	[Description( "The CIM_PointingDevice class represents a device used to point to "
				"regions on the display. Membership criteria: Any device used to manipulate "
				"a pointer or point to regions on a visual display is a member of this class. "
				"Example: A mouse, stylus, touch pad, or tablet."): ToSubclass, dynamic: ToInstance, Locale( 1033), 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C535-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_PointingDevice"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PointingDevice:CIM_UserDevice
{
		[Description( "Integer indicating whether the pointing device is configured for "
				"right (value=2) or left handed operation (value=3). Also, the values, \"Unknown\" "
				"(0) and \"Not Applicable\" (1), can be defined."): ToSubclass, DisplayName{ 
		"Handedness"}, PropertySources{ "Handedness"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Not Applicable", "Right Handed Operation", "Left Handed Operation"}: 
		ToSubclass]
	UINT16 Handedness;
		[Description( "The NumberOfButtons property indicates the number of buttons on "
				"the pointing device./nExample: 2"): ToSubclass, DisplayName{ "NumberOfButtons"}, 
		PropertySources{ "NumberOfButtons"}: ToSubclass, read: ToSubclass]
	UINT8 NumberOfButtons;
		[Description( "The type of the pointing device."): ToSubclass, DisplayName{ "PointingType"}, 
		MappingStrings{ "MIF.DMTF|Pointing Device|001.1"}: ToSubclass, PropertySources{ 
		"PointingType"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5", "6", "7", "8", "9"}: ToSubclass, Values{ "Other", "Unknown", "Mouse", "Track "
				"Ball", "Track Point", "Glide Point", "Touch Pad", "Touch Screen", "Mouse "
				"- Optical Sensor"}: ToSubclass]
	UINT16 PointingType;
		[Description( "The Resolution property indicates the tracking resolution./nExample: "
				"0"): ToSubclass, DisplayName{ "Resolution"}, PropertySources{ "Resolution"}: 
		ToSubclass, read: ToSubclass, Units( "Counts per Inch"): ToSubclass]
	UINT32 Resolution;
};
	[Description( "Capabilities and management of the keyboard logical device."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C534-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Keyboard"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Keyboard:CIM_UserDevice
{
		[Description( "A free-form string indicating the format and layout of the Keyboard."): 
		ToSubclass, DisplayName{ "Layout"}, PropertySources{ "Layout"}: ToSubclass, read: 
		ToSubclass]
	STRING Layout;
		[Description( "Number of function keys on the Keyboard."): ToSubclass, DisplayName{ 
		"NumberOfFunctionKeys"}, PropertySources{ "NumberOfFunctionKeys"}: ToSubclass, 
		read: ToSubclass]
	UINT16 NumberOfFunctionKeys;
		[Description( "An integer indicating whether a hardware-level password is enabled "
				"at the keyboard (value=4), preventing local input. Other values are:  \"Disabled\" "
				"(3), \"Not Implemented\" (5), \"Other\" (1) and \"Unknown\" (2)."): ToSubclass, 
		DisplayName{ "Password"}, MappingStrings{ "MIF.DMTF|System Hardware Security|001.2"}: 
		ToSubclass, PropertySources{ "Password"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5"}: ToSubclass, Values{ "Other", "Unknown", "Disabled", 
		"Enabled", "Not Implemented"}: ToSubclass]
	UINT16 Password;
};
	[abstract, Description( "The CIM_Display class is a superclass for grouping the "
				"miscellaneous display devices that exist."): ToSubclass, Locale( 1033), 
				UUID( "{1008CCE7-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance]
class CIM_Display:CIM_UserDevice
{
};
	[Description( "Capabilities and management of the desktop monitor (CRT) logical "
				"device."): ToSubclass, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{1008CCE8-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_DesktopMonitor"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DesktopMonitor:CIM_Display
{
		[Description( "Monitor's bandwidth in MegaHertz. If unknown, enter 0."): ToSubclass, 
		DisplayName{ "Bandwidth"}, PropertySources{ "Bandwidth"}: ToSubclass, read: ToSubclass, 
		Units( "MegaHertz"): ToSubclass]
	UINT32 Bandwidth;
		[Description( "The type of desktop monitor or CRT. For example, multiscan color "
				"or monochrome monitors (values 2 or 3, respectively) can be indicated in "
				"this property."): ToSubclass, DisplayName{ "DisplayType"}, PropertySources{ 
		"DisplayType"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Multiscan "
				"Color", "Multiscan Monochrome", "Fixed Frequency Color", "Fixed Frequency "
				"Monochrome"}: ToSubclass]
	UINT16 DisplayType;
		[Description( "The logical height of the display in screen coordinates."): ToSubclass, 
		DisplayName{ "ScreenHeight"}, PropertySources{ "ScreenHeight"}: ToSubclass, read: 
		ToSubclass]
	UINT32 ScreenHeight;
		[Description( "The logical width of the display in screen coordinates."): ToSubclass, 
		DisplayName{ "ScreenWidth"}, PropertySources{ "ScreenWidth"}: ToSubclass, read: 
		ToSubclass]
	UINT32 ScreenWidth;
};
	[abstract, Description( "Capabilities and management of the flat panel logical "
				"device."): ToSubclass, 
		Locale( 1033), UUID( "{1008CCE9-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance]
class CIM_FlatPanel:CIM_Display
{
		[Description( "An integer enumeration describing the type of flat panel display."): 
		ToSubclass, DisplayName{ "DisplayType"}, PropertySources{ "DisplayType"}: ToSubclass, 
		read: ToSubclass, Values{ "Unknown", "Other", "Passive Matrix LCD", "Active Matrix "
				"LCD", "Cholesteric LCD", "Field Emission Display", "Electro Luminescent Display", 
		"Gas Plasma", "LED"}: ToSubclass]
	UINT16 DisplayType;
		[Description( "Flat panel's horizontal resolution in Pixels."): ToSubclass, DisplayName{ 
		"HorizontalResolution"}, PropertySources{ "HorizontalResolution"}: ToSubclass, 
		read: ToSubclass, Units( "Pixels"): ToSubclass]
	UINT32 HorizontalResolution;
		[Description( "A description of the display illumination type. For example, backlit "
				"(value=2) or reflective (4) can be specified."): ToSubclass, DisplayName{ 
		"LightSource"}, PropertySources{ "LightSource"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "Backlit", "Edgelit", "Reflective"}: ToSubclass]
	UINT16 LightSource;
		[Description( "A Flat panel's scan mode indicating either single (value=2) or "
				"dual scan (3)."): ToSubclass, DisplayName{ "ScanMode"}, PropertySources{ 
		"ScanMode"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Single "
				"Scan", "Dual Scan"}: ToSubclass]
	UINT16 ScanMode;
		[Description( "Boolean indicating whether the flat panel supports color display."): 
		ToSubclass, DisplayName{ "SupportsColor"}, PropertySources{ "SupportsColor"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN SupportsColor;
		[Description( "Flat panel's vertical resolution in Pixels."): ToSubclass, DisplayName{ 
		"VerticalResolution"}, PropertySources{ "VerticalResolution"}: ToSubclass, read: 
		ToSubclass, Units( "Pixels"): ToSubclass]
	UINT32 VerticalResolution;
};
	[abstract, Description( "The CIM_Sensor class represents a hardware device capable "
				"of measuring the characteristics of some physical property - for example, "
				"the temperature or voltage characteristics of a unitary computersystem."): 
		ToSubclass, Locale( 
		1033), UUID( "{9565979B-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_Sensor:CIM_LogicalDevice
{
};
	[abstract, Description( "A numeric sensor is capable of returning numeric readings "
				"and optionally supports thresholds settings."): ToSubclass, Locale( 1033), 
				UUID( "{9565979C-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_NumericSensor:CIM_Sensor
{
		[Description( "Indicates the accuracy of the sensor for the measured property. "
				"Its value is recorded as plus/minus hundredths of a percent. Accuracy, along "
				"with resolution and tolerance, is used to calculate the actual value of the "
				"measured physical property. Accuracy may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Accuracy"}, 
		PropertySources{ "Accuracy"}: ToSubclass, read: ToSubclass, Units( "Hundredths "
				"of Percent"): ToSubclass]
	SINT32 Accuracy;
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, PropertySources{ "CurrentReading"}: ToSubclass, read: ToSubclass]
	SINT32 CurrentReading;
		[Description( "Indicates that the sensor is linear over its dynamic range."): 
		ToSubclass, DisplayName{ "IsLinear"}, PropertySources{ "IsLinear"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN IsLinear;
		[Description( "The Sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdCritical "
				"and LowerThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "LowerThresholdCritical"}, PropertySources{ "LowerThresholdCritical"}: 
		ToSubclass, read: ToSubclass]
	SINT32 LowerThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is below LowerThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "LowerThresholdFatal"}, 
		PropertySources{ "LowerThresholdFatal"}: ToSubclass, read: ToSubclass]
	SINT32 LowerThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If CurrentReading is between LowerThresholdNonCritical and LowerThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "LowerThresholdNonCritical"}, 
		PropertySources{ "LowerThresholdNonCritical"}: ToSubclass, read: ToSubclass]
	SINT32 LowerThresholdNonCritical;
		[Description( "MaxReadable indicates the largest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MaxReadable"}, 
		PropertySources{ "MaxReadable"}: ToSubclass, read: ToSubclass]
	SINT32 MaxReadable;
		[Description( "MinReadable indicates the smallest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MinReadable"}, 
		PropertySources{ "MinReadable"}: ToSubclass, read: ToSubclass]
	SINT32 MinReadable;
		[Description( "NominalReading indicates the 'normal' or expected value for the "
				"numeric sensor."): ToSubclass, DisplayName{ "NominalReading"}, PropertySources{ 
		"NominalReading"}: ToSubclass, read: ToSubclass]
	SINT32 NominalReading;
		[Description( "NormalMax provides guidance for the user as to the normal maximum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMax"}, PropertySources{ 
		"NormalMax"}: ToSubclass, read: ToSubclass]
	SINT32 NormalMax;
		[Description( "NormalMin provides guidance for the user as to the normal minimum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMin"}, PropertySources{ 
		"NormalMin"}: ToSubclass, read: ToSubclass]
	SINT32 NormalMin;
		[Description( "Resolution indicates the ability of the sensor to resolve differences "
				"in the measured property.  This value may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Resolution"}, 
		PropertySources{ "Resolution"}: ToSubclass, read: ToSubclass]
	UINT32 Resolution;
		[Description( "Indicates the tolerance of the sensor for the measured property. "
				"Tolerance, along with resolution and accuracy, is used to calculate the actual "
				"value of the measured physical property.  Tolerance may vary depending on "
				"whether the device is linear over its dynamic range."): ToSubclass, DisplayName{ 
		"Tolerance"}, PropertySources{ "Tolerance"}: ToSubclass, read: ToSubclass]
	SINT32 Tolerance;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between UpperThresholdCritical "
				"and UpperThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "UpperThresholdCritical"}, PropertySources{ "UpperThresholdCritical"}: 
		ToSubclass, read: ToSubclass]
	SINT32 UpperThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is above UpperThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "UpperThresholdFatal"}, 
		PropertySources{ "UpperThresholdFatal"}: ToSubclass, read: ToSubclass]
	SINT32 UpperThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If the CurrentReading is between UpperThresholdNonCritical and UpperThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "UpperThresholdNonCritical"}, 
		PropertySources{ "UpperThresholdNonCritical"}: ToSubclass, read: ToSubclass]
	SINT32 UpperThresholdNonCritical;
};
	[Description( "This class exists for backward compatibility to earlier CIM Schema "
				"definitions. With additions to Sensor and NumericSensor in V2.2, it is no "
				"longer necessary. A VoltageSensor can be defined by setting the SensorType "
				"property, inherited from Sensor, to 3 (\"Voltage\"). Other properties of "
				"this class are hard-coded to constant values to correspond to definitions "
				"in the sensor hierarchy."): ToSubclass, dynamic: ToInstance, 
				Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{A998F9B4-E3D4-11d2-8601-0000F8102E5F}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_VoltageSensor"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_VoltageSensor:CIM_NumericSensor
{
		[Description( "Indicates the accuracy of the sensor for the measured property. "
				"Its value is recorded as plus/minus hundredths of a percent. Accuracy, along "
				"with resolution and tolerance, is used to calculate the actual value of the "
				"measured physical property. Accuracy may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Accuracy"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.19"}: ToSubclass, Override( "Accuracy"), 
		PropertySources{ "Accuracy"}: ToSubclass, read: ToSubclass, Units( "Hundredths "
				"of Percent"): ToSubclass]
	SINT32 Accuracy;
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, MappingStrings{ "MIF.DMTF|Voltage Probe|001.5"}: ToSubclass, 
		Override( "CurrentReading"), PropertySources{ "CurrentReading"}: ToSubclass, 
		read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 CurrentReading;
		[Description( "The Sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdCritical "
				"and LowerThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "LowerThresholdCritical"}, MappingStrings{ "MIF.DMTF|Voltage Probe|001.13"}: 
		ToSubclass, Override( "LowerThresholdCritical"), PropertySources{ "LowerThresholdCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 LowerThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is below LowerThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "LowerThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.15"}: ToSubclass, Override( "LowerThresholdFatal"), 
		PropertySources{ "LowerThresholdFatal"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	SINT32 LowerThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If CurrentReading is between LowerThresholdNonCritical and LowerThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "LowerThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.11"}: ToSubclass, Override( "LowerThresholdNonCritical"), 
		PropertySources{ "LowerThresholdNonCritical"}: ToSubclass, read: ToSubclass, 
		Units( "Millivolts"): ToSubclass]
	SINT32 LowerThresholdNonCritical;
		[Description( "MaxReadable indicates the largest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MaxReadable"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.9"}: ToSubclass, Override( "MaxReadable"), 
		PropertySources{ "MaxReadable"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): 
		ToSubclass]
	SINT32 MaxReadable;
		[Description( "MinReadable indicates the smallest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MinReadable"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.10"}: ToSubclass, Override( "MinReadable"), 
		PropertySources{ "MinReadable"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): 
		ToSubclass]
	SINT32 MinReadable;
		[Description( "NominalReading indicates the 'normal' or expected value for the "
				"numeric sensor."): ToSubclass, DisplayName{ "NominalReading"}, MappingStrings{ 
		"MIF.DMTF|Voltage Probe|001.6"}: ToSubclass, Override( "NominalReading"), PropertySources{ 
		"NominalReading"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 NominalReading;
		[Description( "NormalMax provides guidance for the user as to the normal maximum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMax"}, MappingStrings{ 
		"MIF.DMTF|Voltage Probe|001.7"}: ToSubclass, Override( "NormalMax"), PropertySources{ 
		"NormalMax"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 NormalMax;
		[Description( "NormalMin provides guidance for the user as to the normal minimum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMin"}, MappingStrings{ 
		"MIF.DMTF|Voltage Probe|001.8"}: ToSubclass, Override( "NormalMin"), PropertySources{ 
		"NormalMin"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 NormalMin;
		[Description( "Resolution indicates the ability of the sensor to resolve differences "
				"in the measured property.  This value may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Resolution"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.17"}: ToSubclass, Override( "Resolution"), 
		PropertySources{ "Resolution"}: ToSubclass, read: ToSubclass, Units( "Tenths "
				"of Millivolts"): ToSubclass]
	UINT32 Resolution;
		[Description( "Indicates the tolerance of the sensor for the measured property. "
				"Tolerance, along with resolution and accuracy, is used to calculate the actual "
				"value of the measured physical property.  Tolerance may vary depending on "
				"whether the device is linear over its dynamic range."): ToSubclass, DisplayName{ 
		"Tolerance"}, MappingStrings{ "MIF.DMTF|Voltage Probe|001.18"}: ToSubclass, Override( 
		"Tolerance"), PropertySources{ "Tolerance"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	SINT32 Tolerance;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between UpperThresholdCritical "
				"and UpperThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "UpperThresholdCritical"}, MappingStrings{ "MIF.DMTF|Voltage Probe|001.14"}: 
		ToSubclass, Override( "UpperThresholdCritical"), PropertySources{ "UpperThresholdCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	SINT32 UpperThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is above UpperThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "UpperThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.16"}: ToSubclass, Override( "UpperThresholdFatal"), 
		PropertySources{ "UpperThresholdFatal"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	SINT32 UpperThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If the CurrentReading is between UpperThresholdNonCritical and UpperThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "UpperThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Voltage Probe|001.12"}: ToSubclass, Override( "UpperThresholdNonCritical"), 
		PropertySources{ "UpperThresholdNonCritical"}: ToSubclass, read: ToSubclass, 
		Units( "Millivolts"): ToSubclass]
	SINT32 UpperThresholdNonCritical;
};
	[Description( "This class exists for backward compatibility to earlier CIM Schema "
				"definitions. With additions to Sensor and NumericSensor in V2.2, it is no "
				"longer necessary. A TempertatureSensor can be defined by setting the SensorType "
				"property, inherited from Sensor, to 2 (\"Temperature\"). Other properties "
				"of this class are hard-coded to constant values to correspond to definitions "
				"in the sensor hierarchy."): ToSubclass, dynamic: ToInstance, Locale( 1033), 
				provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
				UUID( "{9565979D-7D80-11D2-AAD3-006008C78BC7}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_TemperatureSensor"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_TemperatureSensor:CIM_NumericSensor
{
		[Description( "Indicates the accuracy of the sensor for the measured property. "
				"Its value is recorded as plus/minus hundredths of a percent. Accuracy, along "
				"with resolution and tolerance, is used to calculate the actual value of the "
				"measured physical property. Accuracy may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Accuracy"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.19"}: ToSubclass, Override( "Accuracy"), 
		PropertySources{ "Accuracy"}: ToSubclass, read: ToSubclass, Units( "Hundredths "
				"of Percent"): ToSubclass]
	SINT32 Accuracy;
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, MappingStrings{ "MIF.DMTF|Temperature Probe|001.5"}: ToSubclass, 
		Override( "CurrentReading"), PropertySources{ "CurrentReading"}: ToSubclass, 
		read: ToSubclass, Units( "Tenths of degrees Centigrade"): ToSubclass]
	SINT32 CurrentReading;
		[Description( "The Sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdCritical "
				"and LowerThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "LowerThresholdCritical"}, MappingStrings{ "MIF.DMTF|Temperature "
				"Probe|001.13"}: ToSubclass, Override( "LowerThresholdCritical"), PropertySources{ 
		"LowerThresholdCritical"}: ToSubclass, read: ToSubclass, Units( "Tenths of degrees "
				"Centigrade"): ToSubclass]
	SINT32 LowerThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is below LowerThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "LowerThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.15"}: ToSubclass, Override( "LowerThresholdFatal"), 
		PropertySources{ "LowerThresholdFatal"}: ToSubclass, read: ToSubclass, Units( 
		"Tenths of degrees Centigrade"): ToSubclass]
	SINT32 LowerThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If CurrentReading is between LowerThresholdNonCritical and LowerThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "LowerThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.11"}: ToSubclass, Override( "LowerThresholdNonCritical"), 
		PropertySources{ "LowerThresholdNonCritical"}: ToSubclass, read: ToSubclass, 
		Units( "Tenths of degrees Centigrade"): ToSubclass]
	SINT32 LowerThresholdNonCritical;
		[Description( "MaxReadable indicates the largest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MaxReadable"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.9"}: ToSubclass, Override( "MaxReadable"), 
		PropertySources{ "MaxReadable"}: ToSubclass, read: ToSubclass, Units( "Tenths "
				"of degrees Centigrade"): ToSubclass]
	SINT32 MaxReadable;
		[Description( "MinReadable indicates the smallest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MinReadable"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.10"}: ToSubclass, Override( "MinReadable"), 
		PropertySources{ "MinReadable"}: ToSubclass, read: ToSubclass, Units( "Tenths "
				"of degrees Centigrade"): ToSubclass]
	SINT32 MinReadable;
		[Description( "NominalReading indicates the 'normal' or expected value for the "
				"numeric sensor."): ToSubclass, DisplayName{ "NominalReading"}, MappingStrings{ 
		"MIF.DMTF|Temperature Probe|001.6"}: ToSubclass, Override( "NominalReading"), 
		PropertySources{ "NominalReading"}: ToSubclass, read: ToSubclass, Units( "Tenths "
				"of degrees Centigrade"): ToSubclass]
	SINT32 NominalReading;
		[Description( "NormalMax provides guidance for the user as to the normal maximum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMax"}, MappingStrings{ 
		"MIF.DMTF|Temperature Probe|001.7"}: ToSubclass, Override( "NormalMax"), PropertySources{ 
		"NormalMax"}: ToSubclass, read: ToSubclass, Units( "Tenths of degrees Centigrade"): 
		ToSubclass]
	SINT32 NormalMax;
		[Description( "NormalMin provides guidance for the user as to the normal minimum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMin"}, MappingStrings{ 
		"MIF.DMTF|Temperature Probe|001.8"}: ToSubclass, Override( "NormalMin"), PropertySources{ 
		"NormalMin"}: ToSubclass, read: ToSubclass, Units( "Tenths of degrees Centigrade"): 
		ToSubclass]
	SINT32 NormalMin;
		[Description( "Resolution indicates the ability of the sensor to resolve differences "
				"in the measured property.  This value may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Resolution"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.17"}: ToSubclass, Override( "Resolution"), 
		PropertySources{ "Resolution"}: ToSubclass, read: ToSubclass, Units( "Hundredths "
				"of degrees Centigrade"): ToSubclass]
	UINT32 Resolution;
		[Description( "Indicates the tolerance of the sensor for the measured property. "
				"Tolerance, along with resolution and accuracy, is used to calculate the actual "
				"value of the measured physical property.  Tolerance may vary depending on "
				"whether the device is linear over its dynamic range."): ToSubclass, DisplayName{ 
		"Tolerance"}, MappingStrings{ "MIF.DMTF|Temperature Probe|001.18"}: ToSubclass, 
		Override( "Tolerance"), PropertySources{ "Tolerance"}: ToSubclass, read: ToSubclass, 
		Units( "Tenths of degrees Centigrade"): ToSubclass]
	SINT32 Tolerance;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between UpperThresholdCritical "
				"and UpperThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "UpperThresholdCritical"}, MappingStrings{ "MIF.DMTF|Temperature "
				"Probe|001.14"}: ToSubclass, Override( "UpperThresholdCritical"), PropertySources{ 
		"UpperThresholdCritical"}: ToSubclass, read: ToSubclass, Units( "Tenths of degrees "
				"Centigrade"): ToSubclass]
	SINT32 UpperThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is above UpperThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "UpperThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.16"}: ToSubclass, Override( "UpperThresholdFatal"), 
		PropertySources{ "UpperThresholdFatal"}: ToSubclass, read: ToSubclass, Units( 
		"Tenths of degrees Centigrade"): ToSubclass]
	SINT32 UpperThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If the CurrentReading is between UpperThresholdNonCritical and UpperThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "UpperThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Temperature Probe|001.12"}: ToSubclass, Override( "UpperThresholdNonCritical"), 
		PropertySources{ "UpperThresholdNonCritical"}: ToSubclass, read: ToSubclass, 
		Units( "Tenths of degrees Centigrade"): ToSubclass]
	SINT32 UpperThresholdNonCritical;
};
	[abstract, Description( "This class exists for backward compatibility to earlier "
				"CIM Schema definitions. With additions to Sensor and NumericSensor in V2.2, "
				"it is no longer necessary. A Tachometer can be defined by setting the SensorType "
				"property. inherited from Sensor, to 5 (\"Tachometer\"). Other properties "
				"of this class are hard-coded to constant values to correspond to definitions "
				"in the Sensor hierarchy."): ToSubclass, Locale( 1033), 
				UUID( "{237D964F-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_Tachometer:CIM_NumericSensor
{
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, Override( "CurrentReading"), PropertySources{ "CurrentReading"}: 
		ToSubclass, read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 CurrentReading;
		[Description( "The Sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdCritical "
				"and LowerThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "LowerThresholdCritical"}, Override( "LowerThresholdCritical"), 
		PropertySources{ "LowerThresholdCritical"}: ToSubclass, read: ToSubclass, Units( 
		"Revolutions per Minute"): ToSubclass]
	SINT32 LowerThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is below LowerThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "LowerThresholdFatal"}, 
		Override( "LowerThresholdFatal"), PropertySources{ "LowerThresholdFatal"}: ToSubclass, 
		read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 LowerThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If CurrentReading is between LowerThresholdNonCritical and LowerThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "LowerThresholdNonCritical"}, 
		Override( "LowerThresholdNonCritical"), PropertySources{ "LowerThresholdNonCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 LowerThresholdNonCritical;
		[Description( "MaxReadable indicates the largest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MaxReadable"}, 
		Override( "MaxReadable"), PropertySources{ "MaxReadable"}: ToSubclass, read: 
		ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 MaxReadable;
		[Description( "MinReadable indicates the smallest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MinReadable"}, 
		Override( "MinReadable"), PropertySources{ "MinReadable"}: ToSubclass, read: 
		ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 MinReadable;
		[Description( "NominalReading indicates the 'normal' or expected value for the "
				"numeric sensor."): ToSubclass, DisplayName{ "NominalReading"}, Override( 
		"NominalReading"), PropertySources{ "NominalReading"}: ToSubclass, read: ToSubclass, 
		Units( "Revolutions per Minute"): ToSubclass]
	SINT32 NominalReading;
		[Description( "NormalMax provides guidance for the user as to the normal maximum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMax"}, Override( 
		"NormalMax"), PropertySources{ "NormalMax"}: ToSubclass, read: ToSubclass, Units( 
		"Revolutions per Minute"): ToSubclass]
	SINT32 NormalMax;
		[Description( "NormalMin provides guidance for the user as to the normal minimum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMin"}, Override( 
		"NormalMin"), PropertySources{ "NormalMin"}: ToSubclass, read: ToSubclass, Units( 
		"Revolutions per Minute"): ToSubclass]
	SINT32 NormalMin;
		[Description( "Resolution indicates the ability of the sensor to resolve differences "
				"in the measured property.  This value may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Resolution"}, 
		Override( "Resolution"), PropertySources{ "Resolution"}: ToSubclass, read: ToSubclass, 
		Units( "Tenths of Revolutions per Minute"): ToSubclass]
	UINT32 Resolution;
		[Description( "Indicates the tolerance of the sensor for the measured property. "
				"Tolerance, along with resolution and accuracy, is used to calculate the actual "
				"value of the measured physical property.  Tolerance may vary depending on "
				"whether the device is linear over its dynamic range."): ToSubclass, DisplayName{ 
		"Tolerance"}, Override( "Tolerance"), PropertySources{ "Tolerance"}: ToSubclass, 
		read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 Tolerance;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between UpperThresholdCritical "
				"and UpperThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "UpperThresholdCritical"}, Override( "UpperThresholdCritical"), 
		PropertySources{ "UpperThresholdCritical"}: ToSubclass, read: ToSubclass, Units( 
		"Revolutions per Minute"): ToSubclass]
	SINT32 UpperThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is above UpperThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "UpperThresholdFatal"}, 
		Override( "UpperThresholdFatal"), PropertySources{ "UpperThresholdFatal"}: ToSubclass, 
		read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 UpperThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If the CurrentReading is between UpperThresholdNonCritical and UpperThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "UpperThresholdNonCritical"}, 
		Override( "UpperThresholdNonCritical"), PropertySources{ "UpperThresholdNonCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Revolutions per Minute"): ToSubclass]
	SINT32 UpperThresholdNonCritical;
};
	[Description( "This class exists for backward compatibility to earlier CIM Schema "
				"definitions. With additions to Sensor and NumericSensor in V2.2, it is no "
				"longer necessary. A CurrentSensor can be defined by setting the SensorType "
				"property, inherited from Sensor, to 4 (\"Current\"). Other properties of "
				"this class are hard-coded to constant values to correspond to definitions "
				"in the sensor hierarchy."): ToSubclass, dynamic: ToInstance, 
				Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{DCA1D084-E3D3-11d2-8601-0000F8102E5F}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_CurrentSensor"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_CurrentSensor:CIM_NumericSensor
{
		[Description( "Indicates the accuracy of the sensor for the measured property. "
				"Its value is recorded as plus/minus hundredths of a percent. Accuracy, along "
				"with resolution and tolerance, is used to calculate the actual value of the "
				"measured physical property. Accuracy may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Accuracy"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.19"}: ToSubclass, Override( 
		"Accuracy"), PropertySources{ "Accuracy"}: ToSubclass, read: ToSubclass, Units( 
		"Hundredths of Percent"): ToSubclass]
	SINT32 Accuracy;
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.5"}: 
		ToSubclass, Override( "CurrentReading"), PropertySources{ "CurrentReading"}: 
		ToSubclass, read: ToSubclass, Units( "Milliamps"): ToSubclass]
	SINT32 CurrentReading;
		[Description( "The Sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdCritical "
				"and LowerThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "LowerThresholdCritical"}, MappingStrings{ "MIF.DMTF|Electrical "
				"Current Probe|001.13"}: ToSubclass, Override( "LowerThresholdCritical"), 
		PropertySources{ "LowerThresholdCritical"}: ToSubclass, read: ToSubclass, Units( 
		"Milliamps"): ToSubclass]
	SINT32 LowerThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is below LowerThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "LowerThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.15"}: ToSubclass, Override( 
		"LowerThresholdFatal"), PropertySources{ "LowerThresholdFatal"}: ToSubclass, 
		read: ToSubclass, Units( "Milliamps"): ToSubclass]
	SINT32 LowerThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If CurrentReading is between LowerThresholdNonCritical and LowerThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "LowerThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.11"}: ToSubclass, Override( 
		"LowerThresholdNonCritical"), PropertySources{ "LowerThresholdNonCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Milliamps"): ToSubclass]
	SINT32 LowerThresholdNonCritical;
		[Description( "MaxReadable indicates the largest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MaxReadable"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.9"}: ToSubclass, Override( 
		"MaxReadable"), PropertySources{ "MaxReadable"}: ToSubclass, read: ToSubclass, 
		Units( "Milliamps"): ToSubclass]
	SINT32 MaxReadable;
		[Description( "MinReadable indicates the smallest value of the measured property "
				"that can be read by the numeric sensor."): ToSubclass, DisplayName{ "MinReadable"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.10"}: ToSubclass, Override( 
		"MinReadable"), PropertySources{ "MinReadable"}: ToSubclass, read: ToSubclass, 
		Units( "Milliamps"): ToSubclass]
	SINT32 MinReadable;
		[Description( "NominalReading indicates the 'normal' or expected value for the "
				"numeric sensor."): ToSubclass, DisplayName{ "NominalReading"}, MappingStrings{ 
		"MIF.DMTF|Electrical Current Probe|001.6"}: ToSubclass, Override( "NominalReading"), 
		PropertySources{ "NominalReading"}: ToSubclass, read: ToSubclass, Units( "Milliamps"): 
		ToSubclass]
	SINT32 NominalReading;
		[Description( "NormalMax provides guidance for the user as to the normal maximum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMax"}, MappingStrings{ 
		"MIF.DMTF|Electrical Current Probe|001.7"}: ToSubclass, Override( "NormalMax"), 
		PropertySources{ "NormalMax"}: ToSubclass, read: ToSubclass, Units( "Milliamps"): 
		ToSubclass]
	SINT32 NormalMax;
		[Description( "NormalMin provides guidance for the user as to the normal minimum "
				"range for the numeric sensor."): ToSubclass, DisplayName{ "NormalMin"}, MappingStrings{ 
		"MIF.DMTF|Electrical Current Probe|001.8"}: ToSubclass, Override( "NormalMin"), 
		PropertySources{ "NormalMin"}: ToSubclass, read: ToSubclass, Units( "Milliamps"): 
		ToSubclass]
	SINT32 NormalMin;
		[Description( "Resolution indicates the ability of the sensor to resolve differences "
				"in the measured property.  This value may vary depending on whether the device "
				"is linear over its dynamic range."): ToSubclass, DisplayName{ "Resolution"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.17"}: ToSubclass, Override( 
		"Resolution"), PropertySources{ "Resolution"}: ToSubclass, read: ToSubclass, 
		Units( "Tenths of Milliamps"): ToSubclass]
	UINT32 Resolution;
		[Description( "Indicates the tolerance of the sensor for the measured property. "
				"Tolerance, along with resolution and accuracy, is used to calculate the actual "
				"value of the measured physical property.  Tolerance may vary depending on "
				"whether the device is linear over its dynamic range."): ToSubclass, DisplayName{ 
		"Tolerance"}, MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.18"}: ToSubclass, 
		Override( "Tolerance"), PropertySources{ "Tolerance"}: ToSubclass, read: ToSubclass, 
		Units( "Milliamps"): ToSubclass]
	SINT32 Tolerance;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between UpperThresholdCritical "
				"and UpperThresholdFatal, then the CurrentState is Critical."): ToSubclass, 
		DisplayName{ "UpperThresholdCritical"}, MappingStrings{ "MIF.DMTF|Electrical "
				"Current Probe|001.14"}: ToSubclass, Override( "UpperThresholdCritical"), 
		PropertySources{ "UpperThresholdCritical"}: ToSubclass, read: ToSubclass, Units( 
		"Milliamps"): ToSubclass]
	SINT32 UpperThresholdCritical;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is above UpperThresholdFatal, "
				"then the CurrentState is Fatal."): ToSubclass, DisplayName{ "UpperThresholdFatal"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.16"}: ToSubclass, Override( 
		"UpperThresholdFatal"), PropertySources{ "UpperThresholdFatal"}: ToSubclass, 
		read: ToSubclass, Units( "Milliamps"): ToSubclass]
	SINT32 UpperThresholdFatal;
		[Description( "The sensor's threshold values specify the ranges (min and max values) "
				"for determining whether the Sensor is operating under Normal, NonCritical, "
				"Critical or Fatal conditions. If the CurrentReading is between LowerThresholdNonCritical "
				"and UpperThresholdNonCritical, then the Sensor is reporting a normal value. "
				"If the CurrentReading is between UpperThresholdNonCritical and UpperThresholdCritical, "
				"then the CurrentState is NonCritical."): ToSubclass, DisplayName{ "UpperThresholdNonCritical"}, 
		MappingStrings{ "MIF.DMTF|Electrical Current Probe|001.12"}: ToSubclass, Override( 
		"UpperThresholdNonCritical"), PropertySources{ "UpperThresholdNonCritical"}: 
		ToSubclass, read: ToSubclass, Units( "Milliamps"): ToSubclass]
	SINT32 UpperThresholdNonCritical;
};
	[abstract, Description( "A multi-state sensor is a multi-member set of binary sensors, "
				"each binary sensor reporting a boolean result."): ToSubclass, Locale( 1033), 
				UUID( "{237D964E-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_MultiStateSensor:CIM_Sensor
{
};
	[abstract, Description( "A DiscreteSensor has a set of legal string values, that "
				"it can report.  These values are enumerated in the Sensor's PossibleValues "
				"property.  A DiscreteSensor will always have a 'current reading' that corresponds "
				"to one of the enumerated values./nGiven the addition of the CurrentState "
				"and PossibleStates properties to Sensor, the DiscreteSensor subclass is no "
				"longer necessary, but is retained for backward compatibility. Information "
				"in the CurrentReading and PossibleValues properties will typically have the "
				"same values and semantics as for the CurrentState and PossibleStates properties, "
				"inherited from Sensor."): ToSubclass, Locale( 1033), UUID( "{1BF00330-E3D1-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_DiscreteSensor:CIM_Sensor
{
		[Description( "The AcceptableValues property details which of the strings in the "
				"PossibleValues property are considered 'acceptable' (i.e., 'not an error')."): 
		ToSubclass, DisplayName{ "AcceptableValues"}, MaxLen( 64): ToSubclass, PropertySources{ 
		"AcceptableValues"}: ToSubclass, read: ToSubclass]
	STRING AcceptableValues[];
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, MaxLen( 64): ToSubclass, PropertySources{ "CurrentReading"}: 
		ToSubclass, read: ToSubclass]
	STRING CurrentReading;
		[Description( "The PossibleValues property enumerates the string outputs that "
				"can be output by the discrete sensor."): ToSubclass, DisplayName{ "PossibleValues"}, 
		MaxLen( 64): ToSubclass, PropertySources{ "PossibleValues"}: ToSubclass, read: 
		ToSubclass]
	STRING PossibleValues[];
};
	[abstract, Description( "A BinarySensor provides a boolean output. Given the addition "
				"of the CurrentState and PossibleStates properties to Sensor, the BinarySensor "
				"subclass is no longer necessary, but is retained for backward compatibility. "
				"A BinarySensor can be created by instantiating a Sensor with two PossibleStates."): 
		ToSubclass, Locale( 
		1033), UUID( "{11140D44-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_BinarySensor:CIM_Sensor
{
		[Description( "The current value indicated by the sensor."): ToSubclass, DisplayName{ 
		"CurrentReading"}, PropertySources{ "CurrentReading"}: ToSubclass, read: ToSubclass]
	BOOLEAN CurrentReading;
		[Description( "ExpectedReading indicates the 'normal' value for the sensor."): 
		ToSubclass, DisplayName{ "ExpectedReading"}, PropertySources{ "ExpectedReading"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN ExpectedReading;
		[Description( "InterpretationOfFalse is a string indicating what a 'False' value "
				"from the binary sensor means.  This information could be displayed to a user."): 
		ToSubclass, DisplayName{ "InterpretationOfFalse"}, MaxLen( 64): ToSubclass, PropertySources{ 
		"InterpretationOfFalse"}: ToSubclass, read: ToSubclass]
	STRING InterpretationOfFalse;
		[Description( "InterpretationOfTrue is a string indicating what a 'True' value "
				"from the Binary sensor means.  This information could be displayed to a user."): 
		ToSubclass, DisplayName{ "InterpretationOfTrue"}, MaxLen( 64): ToSubclass, PropertySources{ 
		"InterpretationOfTrue"}: ToSubclass, read: ToSubclass]
	STRING InterpretationOfTrue;
};
	[Description( "Controller is a superclass for grouping the miscellaneous control-related "
				"Devices that exist. Examples of Controllers are SCSIControllers, USBControllers, "
				"SerialControllers, ... The Controller class is an abstraction for Devices "
				"with a single protocol stack, which exist primarily for communication to, "
				"and control or reset of downstream (ControlledBy) Devices."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C531-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Controller"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Controller:CIM_LogicalDevice
{
		[Description( "Maximum number of directly addressable entities supported by this "
				"Controller.  A value of 0 should be used if the number is unknown or unlimited."): 
		ToSubclass, DisplayName{ "MaxNumberControlled"}, MappingStrings{ "MIF.DMTF|Bus "
				"Port|001.9"}: ToSubclass, PropertySources{ "MaxNumberControlled"}: ToSubclass, 
		read: ToSubclass]
	UINT32 MaxNumberControlled;
		[Description( "The protocol used by the controller to access 'controlled' devices."): 
		ToSubclass, DisplayName{ "ProtocolSupported"}, MappingStrings{ "MIF.DMTF|Bus "
				"Port|001.2", "MIF.DMTF|Disks|003.3"}: ToSubclass, PropertySources{ "ProtocolSupported"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", 
		"9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", 
		"22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", 
		"35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47"}: 
		ToSubclass, Values{ "Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI", "Flexible "
				"Diskette", "1496", "SCSI Parallel Interface", "SCSI Fibre Channel Protocol", 
		"SCSI Serial Bus Protocol", "SCSI Serial Bus Protocol-2 (1394)", "SCSI Serial "
				"Storage Architecture", "VESA", "PCMCIA", "Universal Serial Bus", "Parallel "
				"Protocol", "ESCON", "Diagnostic", "I2C", "Power", "HIPPI", "MultiBus", "VME", 
		"IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5", "IEEE 802.3 10BASE2", "IEEE "
				"802.3 1BASE5", "IEEE 802.3 10BROAD36", "IEEE 802.3 100BASEVG", "IEEE 802.5 "
				"Token-Ring", "ANSI X3T9.5 FDDI", "MCA", "ESDI", "IDE", "CMD", "ST506", "DSSI", 
		"QIC2", "Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)", "FIR (fast infrared)", 
		"SIR (serial infrared)", "IrBus"}: ToSubclass]
	UINT16 ProtocolSupported;
		[Description( "The TimeOfLastReset property indicates the date and time this controller "
				"was last reset.  This could mean the controller was powered down, or reinitialized."): 
		ToSubclass, DisplayName{ "TimeOfLastReset"}, PropertySources{ "TimeOfLastReset"}: 
		ToSubclass, read: ToSubclass]
	DATETIME TimeOfLastReset;
};
	[Description( "Capabilities and management  of a PCMCIA controller."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B5A-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_PCMCIAController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PCMCIAController:CIM_Controller
{
		[Description( "The Manufacturer property indicates the name of the PCMCIA controller "
				"manufacturer./nExample: Acme"): ToSubclass, DisplayName{ "Manufacturer"}, 
		PropertySources{ "Manufacturer"}: ToSubclass, read: ToSubclass, Schema( "Win32"): 
		ToInstance]
	STRING Manufacturer;
};
	[Description( "Capabilities and management of the SCSI controller, logical device."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C553-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_SCSIController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SCSIController:CIM_Controller
{
		[Description( "Number of SCSIController timeouts that have occurred since the "
				"TimeOfLastReset."): ToSubclass, DisplayName{ "ControllerTimeouts"}, PropertySources{ 
		"ControllerTimeouts"}: ToSubclass, read: ToSubclass]
	UINT32 ControllerTimeouts;
		[Description( "Maximum data width (in bits) supported by the SCSIController."): 
		ToSubclass, DisplayName{ "MaxDataWidth"}, PropertySources{ "MaxDataWidth"}: ToSubclass, 
		read: ToSubclass, Units( "Bits"): ToSubclass]
	UINT32 MaxDataWidth;
		[Description( "Maximum transfer rate (in Bits per Second) supported by the SCSIController."): 
		ToSubclass, DisplayName{ "MaxTransferRate"}, PropertySources{ "MaxTransferRate"}: 
		ToSubclass, read: ToSubclass, Units( "Bits per Second"): ToSubclass]
	UINT64 MaxTransferRate;
		[Description( "An integer enumeration indicating whether or not the SCSI controller "
				"provides redundancy or protection against device failures."): ToSubclass, 
		DisplayName{ "ProtectionManagement"}, MappingStrings{ "MIF.DMTF|Storage Controller|001.3"}: 
		ToSubclass, PropertySources{ "ProtectionManagement"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4", "5", "6"}: ToSubclass, Values{ "Other", "Unknown", 
		"Unprotected", "Protected", "Protected through SCC (SCSI-3 Controller Command)", 
		"Protected through SCC-2 (SCSI-3 Controller Command)"}: ToSubclass]
	UINT16 ProtectionManagement;
};
	[Description( "Capabilities and management of a USB controller."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B5B-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_USBController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_USBController:CIM_Controller
{
		[Description( "The Manufacturer property indicates the name of the USB controller "
				" manufacturer./nExample: Acme"): ToSubclass, DisplayName{ "Manufacturer"}, 
		PropertySources{ "Manufacturer"}: ToSubclass, read: ToSubclass, Schema( "Win32"): 
		ToInstance]
	STRING Manufacturer;
};
	[Description( "Capabilities and management  of a management controller.  An I2C "
				"microcontroller is a type of management controller."): ToSubclass, 
		Locale( 1033), UUID( "{7250D62E-E3D0-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ManagementController:CIM_Controller
{
};
	[Description( "Capabilities and management of the serial port, logical device."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C554-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
		"FROM CIM_SerialController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SerialController:CIM_Controller
{
				[ArrayType( "Indexed"): ToSubclass, Description( "The Capabilities property defines "
				"chip level compatibility for the serial controller.  Therefore, this property "
				"describes the buffering and other capabilities of the serial controller, "
				"that may be inherent in the chip hardware. The property is an enumerated "
				"integer."): ToSubclass, DisplayName{ "Capabilities"}, MappingStrings{ "MIF.DMTF|Serial "
				"Ports|004.7"}: ToSubclass, ModelCorrespondence{ "CIM_SerialController.CapabilityDescriptions"}: 
		ToSubclass, PropertySources{ "Capabilities"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5", "6", "160", "161"}: ToSubclass, Values{ "Other", "Unknown", 
		"XT/AT Compatible", "16450 Compatible", "16550 Compatible", "16550A Compatible", 
		"8251 Compatible", "8251FIFO Compatible"}: ToSubclass]
	UINT16 Capabilities[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the serial controller features "
				"indicated in the Capabilities array. Note, each entry of this array is related "
				"to the entry in the Capabilities array that is located at the same index."): 
		ToSubclass, DisplayName{ "CapabilityDescriptions"}, ModelCorrespondence{ "CIM_SerialController.Capabilities"}: 
		ToSubclass, PropertySources{ "CapabilityDescriptions"}: ToSubclass, read: ToSubclass]
	STRING CapabilityDescriptions[];
		[Description( "Maximum baud rate in Bits per Second supported by the SerialController."): 
		ToSubclass, DisplayName{ "MaxBaudRate"}, MappingStrings{ "MIF.DMTF|Serial Ports|004.6"}: 
		ToSubclass, PropertySources{ "MaxBaudRate"}: ToSubclass, read: ToSubclass, Units( 
		"Bits per Second"): ToSubclass]
	UINT32 MaxBaudRate;
};

		[Description( "Capabilities and management of the video controller."): ToSubclass, 
		Locale( 1033), UUID( 
		"{1008CCE5-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance, dynamic: ToInstance, 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, ViewSources{ 
		"SELECT * FROM CIM_PCVideoController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_VideoController:CIM_Controller
{
		[Description( "An array of integers indicating the graphics and 3D capabilities "
				"of the video controller."): ToSubclass, DisplayName{ "AcceleratorCapabilities"}, 
		ModelCorrespondence{ "CIM_VideoController.CapabilityDescriptions"}: ToSubclass, 
		PropertySources{ "AcceleratorCapabilities"}: ToSubclass, read: ToSubclass, Values{ 
		"Unknown", "Other", "Graphics Accelerator", "3D Accelerator"}: ToSubclass]
	UINT16 AcceleratorCapabilities[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the video accelerator features "
				"indicated in the Capabilities array. Note, each entry of this array is related "
				"to the entry in the Capabilities array that is located at the same index."): 
		ToSubclass, DisplayName{ "CapabilityDescriptions"}, ModelCorrespondence{ "CIM_VideoController.AcceleratorCapabilities"}: 
		ToSubclass, PropertySources{ "CapabilityDescriptions"}: ToSubclass, read: ToSubclass]
	STRING CapabilityDescriptions[];
		[Description( "The number of bits used to display each pixel."): ToSubclass, DisplayName{ 
		"CurrentBitsPerPixel"}, MappingStrings{ "MIF.DMTF|Video|003.12"}: ToSubclass, 
		PropertySources{ "CurrentBitsPerPixel"}: ToSubclass, read: ToSubclass, Units( 
		"Bits"): ToSubclass]
	UINT32 CurrentBitsPerPixel;
		[Description( "Current number of horizontal pixels."): ToSubclass, DisplayName{ 
		"CurrentHorizontalResolution"}, MappingStrings{ "MIF.DMTF|Video|003.11"}: ToSubclass, 
		PropertySources{ "CurrentHorizontalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 CurrentHorizontalResolution;
		[Description( "Number of colors supported at the current resolutions."): ToSubclass, 
		DisplayName{ "CurrentNumberOfColors"}, PropertySources{ "CurrentNumberOfColors"}: 
		ToSubclass, read: ToSubclass]
	UINT64 CurrentNumberOfColors;
		[Description( "If in character mode, number of columns for this video controller. "
				"Otherwise, enter 0."): ToSubclass, DisplayName{ "CurrentNumberOfColumns"}, 
		MappingStrings{ "MIF.DMTF|Video|003.14"}: ToSubclass, PropertySources{ "CurrentNumberOfColumns"}: 
		ToSubclass, read: ToSubclass]
	UINT32 CurrentNumberOfColumns;
		[Description( "If in character mode, number of rows for this video controller. "
				"Otherwise, enter 0."): ToSubclass, DisplayName{ "CurrentNumberOfRows"}, MappingStrings{ 
		"MIF.DMTF|Video|003.13"}: ToSubclass, PropertySources{ "CurrentNumberOfRows"}: 
		ToSubclass, read: ToSubclass]
	UINT32 CurrentNumberOfRows;
		[Description( "Current refresh rate in Hertz."): ToSubclass, DisplayName{ "CurrentRefreshRate"}, 
		MappingStrings{ "MIF.DMTF|Video|003.15"}: ToSubclass, PropertySources{ "CurrentRefreshRate"}: 
		ToSubclass, read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 CurrentRefreshRate;
		[Description( "Current scan mode. \"Interlaced\" (value=3) or \"Non Interlaced\" "
				"(4) can be defined using this property."): ToSubclass, DisplayName{ "CurrentScanMode"}, 
		MappingStrings{ "MIF.DMTF|Video|003.8"}: ToSubclass, PropertySources{ "CurrentScanMode"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4"}: ToSubclass, Values{ 
		"Other", "Unknown", "Interlaced", "Non Interlaced"}: ToSubclass]
	UINT16 CurrentScanMode;
		[Description( "Current number of vertical pixels."): ToSubclass, DisplayName{ 
		"CurrentVerticalResolution"}, MappingStrings{ "MIF.DMTF|Video|003.10"}: ToSubclass, 
		PropertySources{ "CurrentVerticalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 CurrentVerticalResolution;
		[Description( "Maximum amount of memory supported in bytes."): ToSubclass, DisplayName{ 
		"MaxMemorySupported"}, PropertySources{ "MaxMemorySupported"}: ToSubclass, read: 
		ToSubclass, Units( "Bytes"): ToSubclass]
	UINT32 MaxMemorySupported;
		[Description( "Maximum refresh rate of the video controller in Hertz."): ToSubclass, 
		DisplayName{ "MaxRefreshRate"}, MappingStrings{ "MIF.DMTF|Video|003.5"}: ToSubclass, 
		PropertySources{ "MaxRefreshRate"}: ToSubclass, read: ToSubclass, Units( "Hertz"): 
		ToSubclass]
	UINT32 MaxRefreshRate;
		[Description( "Minimum refresh rate of the video controller in Hertz."): ToSubclass, 
		DisplayName{ "MinRefreshRate"}, MappingStrings{ "MIF.DMTF|Video|003.4"}: ToSubclass, 
		PropertySources{ "MinRefreshRate"}: ToSubclass, read: ToSubclass, Units( "Hertz"): 
		ToSubclass]
	UINT32 MinRefreshRate;
		[Description( "Number of video pages supported given the current resolutions and "
				"available memory."): ToSubclass, DisplayName{ "NumberOfVideoPages"}, PropertySources{ 
		"NumberOfVideoPages"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfVideoPages;
		[Description( "An integer enumeration indicating the type of video memory."): 
		ToSubclass, DisplayName{ "VideoMemoryType"}, MappingStrings{ "MIF.DMTF|Video|003.6"}: 
		ToSubclass, PropertySources{ "VideoMemoryType"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"}: 
		ToSubclass, Values{ "Other", "Unknown", "VRAM", "DRAM", "SRAM", "WRAM", "EDO "
				"RAM", "Burst Synchronous DRAM", "Pipelined Burst SRAM", "CDRAM", "3DRAM", 
		"SDRAM", "SGRAM"}: ToSubclass]
	UINT16 VideoMemoryType;
		[Description( "A free-form string describing the video processor/Controller."): 
		ToSubclass, DisplayName{ "VideoProcessor"}, PropertySources{ "VideoProcessor"}: 
		ToSubclass, read: ToSubclass]
	STRING VideoProcessor;
};
		[Description( "Capabilities and management of a PC video controller, a subtype "
		"of video controller."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{1008CCE6-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_PCVideoController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PCVideoController:CIM_VideoController
{
		[Description( "Current number of color planes.  If this value is not applicable "
				"for the current video configuration, enter 0."): ToSubclass, DisplayName{ 
		"NumberOfColorPlanes"}, PropertySources{ "NumberOfColorPlanes"}: ToSubclass, 
		read: ToSubclass]
	UINT16 NumberOfColorPlanes;
		[Description( "The video architecture.  For example, VGA (value=5) or PC-98 (160) "
				"may be specified."): ToSubclass, DisplayName{ "VideoArchitecture"}, MappingStrings{ 
		"MIF.DMTF|Video|003.2"}: ToSubclass, PropertySources{ "VideoArchitecture"}: ToSubclass, 
		read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", 
		"11", "12", "160"}: ToSubclass, Values{ "Other", "Unknown", "CGA", "EGA", "VGA", 
		"SVGA", "MDA", "HGC", "MCGA", "8514A", "XGA", "Linear Frame Buffer", "PC-98"}: 
		ToSubclass]
	UINT16 VideoArchitecture;
		[Description( "Current video mode."): ToSubclass, DisplayName{ "VideoMode"}, MappingStrings{ 
		"MIF.DMTF|Video|003.3"}: ToSubclass, PropertySources{ "VideoMode"}: ToSubclass, 
		read: ToSubclass]
	UINT16 VideoMode;
};
	[Description( "PCIController is a superclass for the PCIBridge and PCIDevice classes. "
				"These classes model adapters and bridges on a PCI bus. The properties in "
				"PCIController and its subclasses are defined in the various PCI Specifications "
				"published by the PCI SIG."): ToSubclass, Locale( 1033), UUID( "{7BB67AE8-E3D0-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_PCIController:CIM_Controller
{
};
	[Description( "Capabilities and management of an CIM_InfraredController."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{EDCE42F9-0991-11d3-910A-00105AA630BE}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_InfraredController"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_InfraredController:CIM_Controller
{
};
	[Description( "Capabilities and management of the parallel port logical device"): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C552-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_ParallelController"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_ParallelController:CIM_Controller
{
		[ArrayType( "Indexed"): ToSubclass, Description( "An integer enumeration indicating "
				"the capabilities of the parallel controller"): ToSubclass, DisplayName{ "Capabilities"}, 
		MappingStrings{ "MIF.DMTF|Parallel Ports|003.8"}: ToSubclass, ModelCorrespondence{ 
		"CIM_ParallelController.CapabilityDescriptions"}: ToSubclass, PropertySources{ 
		"Capabilities"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "XT/AT "
				"Compatible", "PS/2 Compatible", "ECP", "EPP", "PC-98", "PC-98-Hireso", "PC-H98"}: 
		ToSubclass]
	UINT16 Capabilities[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the parallel controller features "
				"indicated in the Capabilities array. Note, each entry of this array is related "
				"to the entry in the Capabilities array that is located at the same index."): 
		ToSubclass, DisplayName{ "CapabilityDescriptions"}, ModelCorrespondence{ "CIM_ParallelController.Capabilities"}: 
		ToSubclass, PropertySources{ "CapabilityDescriptions"}: ToSubclass, read: ToSubclass]
	STRING CapabilityDescriptions[];
		[Description( "Set to true if the ParallelController supports DMA."): ToSubclass, 
		DisplayName{ "DMASupport"}, MappingStrings{ "MIF.DMTF|Parallel Ports|003.7"}: 
		ToSubclass, PropertySources{ "DMASupport"}: ToSubclass, read: ToSubclass]
	BOOLEAN DMASupport;
};
	[Description( "The management characterisitics of a USB Device. These "): ToSubclass, 
		dynamic: ToInstance, 
		LOCALE( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, ViewSources{ "SELECT "
				"* FROM CIM_USBDevice"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_USBDevice:CIM_LogicalDevice
{
		[Description( "Indicates the USB class code."): ToSubclass, DisplayName{ "ClassCode"}, 
		PropertySources{ "ClassCode"}: ToSubclass]
	UINT8 ClassCode;
		[Description( "An array of USB 'alternate settings' for each interface in the "
				"currently selected configuration (indicated by the CurrentConfigValue property). "
				"This array has one entry for each interface in the configuration. If the "
				"property, CurrentConfigValue, is zero (indicating the Device is not configured), "
				"the array is undefined. To understand how to parse this octet string, refer "
				"to the USB Specification."): ToSubclass, DisplayName{ "CurrentAlternateSettings"}, 
		ModelCorrespondence{ "CIM_USBDevice.CurrentConfigValue"}: ToSubclass, PropertySources{ 
		"CurrentAlternateSettings"}: ToSubclass]
	UINT8 CurrentAlternateSettings[];
		[Description( "Indicates the configuration currently selected for the Device. "
				"If this value is zero, the Device is unconfigured."): ToSubclass, DisplayName{ 
		"CurrentConfigValue"}, ModelCorrespondence{ "CIM_USBDevice.CurrentAlternateSettings"}: 
		ToSubclass, PropertySources{ "CurrentConfigValue"}: ToSubclass]
	UINT8 CurrentConfigValue;
		[Description( "Number of device configurations that are defined for the Device."): 
		ToSubclass, DisplayName{ "NumberOfConfigs"}, PropertySources{ "NumberOfConfigs"}: 
		ToSubclass]
	UINT8 NumberOfConfigs;
		[Description( "Indicates the USB protocol code."): ToSubclass, DisplayName{ "ProtocolCode"}, 
		PropertySources{ "ProtocolCode"}: ToSubclass]
	UINT8 ProtocolCode;
		[Description( "Indicates the USB subclass code."): ToSubclass, DisplayName{ "SubclassCode"}, 
		PropertySources{ "SubclassCode"}: ToSubclass]
	UINT8 SubclassCode;
		[Description( "Indicates the latest USB Version supported by the USB Device. The "
				"property is expressed as a Binary-Coded Decimal (BCD) where a decimal point "
				"is implied between the 2nd and 3rd digits. For example, a value of 0x201 "
				"indicates that version 2.01 is supported."): ToSubclass, DisplayName{ "USBVersion"}, 
		PropertySources{ "USBVersion"}: ToSubclass]
	UINT16 USBVersion;
		[Description( "This method returns the USBDevice Descriptor as specified by the "
				"input parameters. Each parameter is briefly described here with more detail "
				"in its Qualifier list. RequestType is an input parameter that defines whether "
				"the request is for standard, class or vendor-specific information, as well "
				"as specifying the recipient. RequestValue is also an input parameter and "
				"defines the USB Descriptor Type and Index. RequestIndex is an input parameter "
				"which describes the language used to return a string Descriptor. RequestLength "
				"is both an input and output parameter. It specifies the length of the Descriptor "
				"that should be returned (on input) and what is actually returned in the Buffer "
				"parameter (on output). Buffer is an output parameter, containing the Descriptor "
				"data. The GetDescriptor method returns an integer value of 0 if the USB Descriptor "
				"is successfully returned, 1 if the request is not supported and any other "
				"number to indicate an error./nIn a subclass, the set of possible return codes "
				"could be specified, using a ValueMap qualifier on the method. The strings "
				"to which the ValueMap contents are 'translated' may also be specified in "
				"the subclass as a Values array qualifier."): ToSubclass, DisplayName{ "GetDescriptor"}, 
		MethodSource{ "GetDescriptor"}]
	UINT32 GetDescriptor(
	
		[Description( "Buffer returns the requested Descriptor information. If the Descriptor "
				"does not exist, the contents of the Buffer are undefined."): ToSubclass, 
		DisplayName{ "Buffer"}, ID( 4): DisableOverride  ToInstance, OUT, PropertySources{ 
		"Buffer"}: ToSubclass]
			UINT8 Buffer[],
		[Description( "On input, RequestLength is the length (in octets) of the Descriptor "
				"that should be returned. If this value is less than the actual length of "
				"the Descriptor, only the requested length will be returned. If it is more "
				"than the actual length, the actual length is returned. On output, this parameter "
				"is the length, in octets, of the Buffer being returned. If the requested "
				"Descriptor does not exist, the contents of this parameter are undefined."): 
		ToSubclass, DisplayName{ "RequestLength"}, ID( 3): DisableOverride  ToInstance, 
		OUT, PropertySources{ "RequestLength"}: ToSubclass]
			UINT16 RequestLength,
		[Description( "RequestIndex defines the 2 byte Language ID code used by the USBDevice "
				"when returning string Descriptor data. The parameter is typically 0 for non-string "
				"Descriptors. Refer to the USB Specification for more information."): ToSubclass, 
		DisplayName{ "RequestIndex"}, ID( 2): DisableOverride  ToInstance, IN, PropertySources{ 
		"RequestIndex"}: ToSubclass]
			UINT16 RequestIndex,
		[Description( "On input, RequestLength is the length (in octets) of the Descriptor "
				"that should be returned. If this value is less than the actual length of "
				"the Descriptor, only the requested length will be returned. If it is more "
				"than the actual length, the actual length is returned. On output, this parameter "
				"is the length, in octets, of the Buffer being returned. If the requested "
				"Descriptor does not exist, the contents of this parameter are undefined."): 
		ToSubclass, DisplayName{ "RequestLength"}, ID( 3): DisableOverride  ToInstance, 
		IN, PropertySources{ "RequestLength"}: ToSubclass]
			UINT16 RequestLength,
		[Description( "RequestType is bit-mapped and identifies the type of Descriptor "
				"request and the recipient. The type of request may be 'standard', 'class' "
				"or 'vendor-specific'. The recipient may be 'device', 'interface', 'endpoint' "
				"or 'other'. Refer to the USB Specification for the appropriate values for "
				"each bit."): ToSubclass, DisplayName{ "RequestType"}, ID( 0): DisableOverride 
		 ToInstance, IN, PropertySources{ "RequestType"}: ToSubclass]
			UINT8 RequestType,
		[Description( "RequestValue contains the Descriptor Type in the high byte and "
				"the Descriptor Index (for example, index or offset into the Descriptor array) "
				"in the low byte. Refer to the USB Specification for more information."): 
		ToSubclass, DisplayName{ "RequestValue"}, ID( 1): DisableOverride  ToInstance, 
		IN, PropertySources{ "RequestValue"}: ToSubclass]
			UINT16 RequestValue
	);
};
	[Description( "USB Hub Device."): ToSubclass, dynamic: ToInstance, LOCALE( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, ViewSources{ "SELECT * FROM CIM_USBHub"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_USBHub:CIM_USBDevice
{
		[Description( "Indicates whether power to the Hub Ports is individually or gang-switched. "
				"If this value is FALSE, power is switched individually for each Port. If "
				"this value is TRUE, power is switched to all Ports on the Hub at once."): 
		ToSubclass, DisplayName{ "GangSwitched"}, PropertySources{ "GangSwitched"}: ToSubclass]
	BOOLEAN GangSwitched;
		[Description( "Number of downstream Ports on the Hub, including those embedded "
				"in the Hub's silicon. Individual USBPorts are associated with the Hub using "
				"the USBPortOnHub association."): ToSubclass, DisplayName{ "NumberOfPorts"}, 
		PropertySources{ "NumberOfPorts"}: ToSubclass]
	UINT8 NumberOfPorts;
};
		[abstract, Description( "An alarm device is a type of device that emits audible "
		"or visible indications related to a problem situation. "): ToSubclass, 
		Locale( 1033), UUID( "{FAF76B66-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_AlarmDevice:CIM_LogicalDevice
{
		[Description( "Boolean indicating that the alarm is audible. "): ToSubclass, DisplayName{ 
		"AudibleAlarm"}, PropertySources{ "AudibleAlarm"}: ToSubclass, read: ToSubclass]
	BOOLEAN AudibleAlarm;
		[Description( "Urgency is an enumerated value that indicates the relative frequency "
				"at which the Alarm flashes, vibrates and/or emits audible tones. "): ToSubclass, 
		DisplayName{ "Urgency"}, PropertySources{ "Urgency"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "Not Supported", "Informational", "Non-Critical", 
		"Critical", "Unrecoverable"}: ToSubclass]
	UINT16 Urgency;
		[Description( "Boolean indicating that the alarm is visible. "): ToSubclass, DisplayName{ 
		"VisibleAlarm"}, PropertySources{ "VisibleAlarm"}: ToSubclass, read: ToSubclass]
	BOOLEAN VisibleAlarm;
		[Description( "SetUrgency is a method for defining the desired urgency level for "
				"the alarm. Its input parameter, RequestedUrgency, is specified using the "
				"Values list of CIM_AlarmDevice's Urgency property. SetUrgency returns 0 if "
				"the request is successfully implemented, 1 if the specified urgency level "
				"is not supported, and some other value if any other error occurred."): ToSubclass, 
		DisplayName{ "SetUrgency"}, MethodSource{ "SetUrgency"}]
	UINT32 SetUrgency(
	
		[DisplayName{ "RequestedUrgency"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"RequestedUrgency"}: ToSubclass]
			UINT16 RequestedUrgency
	);
};
	[Description( "Capabilities and management of the processor logical device."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C54B-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_Processor"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Processor:CIM_LogicalDevice
{
		[Description( "Processor address width in bits."): ToSubclass, DisplayName{ "AddressWidth"}, 
		PropertySources{ "AddressWidth"}: ToSubclass, read: ToSubclass, Units( "Bits"): 
		ToSubclass]
	UINT16 AddressWidth;
		[Description( "The current speed (in MHz) of this processor."): ToSubclass, DisplayName{ 
		"CurrentClockSpeed"}, MappingStrings{ "MIF.DMTF|Processor|006.6"}: ToSubclass, 
		PropertySources{ "CurrentClockSpeed"}: ToSubclass, read: ToSubclass, Units( "MegaHertz"): 
		ToSubclass]
	UINT32 CurrentClockSpeed;
		[Description( "Processor data width in bits."): ToSubclass, DisplayName{ "DataWidth"}, 
		PropertySources{ "DataWidth"}: ToSubclass, read: ToSubclass, Units( "Bits"): 
		ToSubclass]
	UINT16 DataWidth;
		[Description( "The processor family type. For example, values include \"Pentium(R) "
				"processor with MMX(TM) technology\" (14) and \"68040\" (96)."): ToSubclass, 
		DisplayName{ "Family"}, MappingStrings{ "SMBIOS|Processor Information|Type 4|Processor "
				"Family"}: ToSubclass, ModelCorrespondence{ "CIM_Processor.OtherFamilyDescription"}: 
		ToSubclass, PropertySources{ "Family"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", 
		"16", "17", "18", "19", "25", "26", "27", "28", "29", "32", "33", "34", "35", 
		"36", "48", "64", "80", "96", "97", "98", "99", "100", "101", "112", "128", "144", 
		"160", "176", "180", "200", "250", "251", "260", "261", "280", "281", "300", 
		"301", "302", "320"}: ToSubclass, Values{ "Other", "Unknown", "8086", "80286", 
		"80386", "80486", "8087", "80287", "80387", "80487", "Pentium Family", "Pentium "
				"Pro", "Pentium II", "Pentium MMX", "Celeron", "Pentium II Xeon", "Pentium "
				"III", "M1 Family", "M2 Family", "K5 Family", "K6 Family", "K6-2", "K6-III", 
		"Athlon", "Power PC Family", "Power PC 601", "Power PC 603", "Power PC 603+", 
		"Power PC 604", "Alpha Family", "MIPS Family", "SPARC Family", "68040", "68xxx "
				"Family", "68000", "68010", "68020", "68030", "Hobbit Family", "Weitek", "PA-RISC "
				"Family", "V30 Family", "Pentium III Xeon", "AS400 Family", "IBM390 Family", 
		"i860", "i960", "SH-3", "SH-4", "ARM", "StrongARM", "6x86", "MediaGX", "MII", 
		"WinChip"}: ToSubclass]
	UINT16 Family;
		[Description( "Loading of this processor, averaged over the last minute, in Percent."): 
		ToSubclass, DisplayName{ "LoadPercentage"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrProcessorLoad"}: 
		ToSubclass, PropertySources{ "LoadPercentage"}: ToSubclass, read: ToSubclass, 
		Units( "Percent"): ToSubclass]
	UINT16 LoadPercentage;
		[Description( "The maximum speed (in MHz) of this processor."): ToSubclass, DisplayName{ 
		"MaxClockSpeed"}, MappingStrings{ "MIF.DMTF|Processor|006.5"}: ToSubclass, PropertySources{ 
		"MaxClockSpeed"}: ToSubclass, read: ToSubclass, Units( "MegaHertz"): ToSubclass]
	UINT32 MaxClockSpeed;
		[Description( "A string describing the processor family type - used when the family "
				"property is set to 1 (\"Other\"). This string should be set to NULL when "
				"the family property is any value other than 1."): ToSubclass, DisplayName{ 
		"OtherFamilyDescription"}, MaxLen( 64): ToSubclass, ModelCorrespondence{ "CIM_Processor.Family"}: 
		ToSubclass, PropertySources{ "OtherFamilyDescription"}: ToSubclass, read: ToSubclass]
	STRING OtherFamilyDescription;
		[Description( "A free form string describing the role of the processor - for example, "
				"\"Central Processor\"' or \"Math Processor\""): ToSubclass, DisplayName{ 
		"Role"}, PropertySources{ "Role"}: ToSubclass, read: ToSubclass]
	STRING Role;
		[Description( "Stepping is a free-form string indicating the revision level of "
				"the processor within the processor family."): ToSubclass, DisplayName{ "Stepping"}, 
		ModelCorrespondence{ "CIM_Processor.Family"}: ToSubclass, PropertySources{ "Stepping"}: 
		ToSubclass, read: ToSubclass]
	STRING Stepping;
		[Description( "A globally unique identifier for the processor.  This identifier "
				"may only be unique within a processor family."): ToSubclass, DisplayName{ 
		"UniqueId"}, PropertySources{ "UniqueId"}: ToSubclass, read: ToSubclass]
	STRING UniqueId;
		[Description( "CPU socket information including data on how this Processor can "
				"be upgraded (if upgrades are supported). This property is an integer enumeration."): 
		ToSubclass, DisplayName{ "UpgradeMethod"}, MappingStrings{ "MIF.DMTF|Processor|006.7"}: 
		ToSubclass, PropertySources{ "UpgradeMethod"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"}: ToSubclass, 
		Values{ "Other", "Unknown", "Daughter Board", "ZIF Socket", "Replacement/Piggy "
				"Back", "None", "LIF Socket", "Slot 1", "Slot 2", "370 Pin Socket", "Slot "
				"A", "Slot M"}: ToSubclass]
	UINT16 UpgradeMethod;
};
	[Description( "Capabilities and management of the battery logical device. This "
				"class applies to both batteries in laptop systems and other internal/external "
				"batteries, such as used in, or as UPSs."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C548-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Battery"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Battery:CIM_LogicalDevice
{
		[Description( "Description of the battery's charge status. Values such as \"Fully "
				"Charged\" (value=3) or \"Partially Charged\" (11) can be specified. The value, "
				"10, is not valid in the CIM Schema since in DMI it represents that no battery "
				"is installed. In this case, this object should not be instantiated."): ToSubclass, 
		DisplayName{ "BatteryStatus"}, MappingStrings{ "MIF.DMTF|Portable Battery|002.14"}: 
		ToSubclass, PropertySources{ "BatteryStatus"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"}: ToSubclass, 
		Values{ "Other", "Unknown", "Fully Charged", "Low", "Critical", "Charging", "Charging "
				"and High", "Charging and Low", "Charging and Critical", "Undefined", "Partially "
				"Charged"}: ToSubclass]
	UINT16 BatteryStatus;
		[Description( "An enumeration that describes the battery's chemistry."): ToSubclass, 
		DisplayName{ "Chemistry"}, MappingStrings{ "MIF.DMTF|Portable Battery|002.7"}: 
		ToSubclass, PropertySources{ "Chemistry"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5", "6", "7", "8"}: ToSubclass, Values{ "Other", "Unknown", 
		"Lead Acid", "Nickel Cadmium", "Nickel Metal Hydride", "Lithium-ion", "Zinc air", 
		"Lithium Polymer"}: ToSubclass]
	UINT16 Chemistry;
		[Description( "The design capacity of the battery in Milliwatt-Hours. If this "
				"property is not supported, enter 0."): ToSubclass, DisplayName{ "DesignCapacity"}, 
		MappingStrings{ "MIF.DMTF|Portable Battery|002.8"}: ToSubclass, PropertySources{ 
		"DesignCapacity"}: ToSubclass, read: ToSubclass, Units( "Milliwatt-Hours"): ToSubclass]
	UINT32 DesignCapacity;
		[Description( "The design voltage of the battery in Millivolts. If this attribute "
				"is not supported, enter 0."): ToSubclass, DisplayName{ "DesignVoltage"}, 
		MappingStrings{ "MIF.DMTF|Portable Battery|002.9"}: ToSubclass, PropertySources{ 
		"DesignVoltage"}: ToSubclass, read: ToSubclass, Units( "Millivolts"): ToSubclass]
	UINT64 DesignVoltage;
		[Description( "An estimate of the percentage of full charge remaining."): ToSubclass, 
		DisplayName{ "EstimatedChargeRemaining"}, PropertySources{ "EstimatedChargeRemaining"}: 
		ToSubclass, read: ToSubclass, Units( "Percent"): ToSubclass]
	UINT16 EstimatedChargeRemaining;
		[Description( "EstimatedRunTime is an estimate in minutes of the time to battery "
				"charge depletion under the present load conditions if the utility power is "
				"off, or lost and remains off, or a Laptop is disconnected from a power source."): 
		ToSubclass, DisplayName{ "EstimatedRunTime"}, MappingStrings{ "MIF.DMTF|Portable "
				"Battery|002.15"}: ToSubclass, PropertySources{ "EstimatedRunTime"}: ToSubclass, 
		read: ToSubclass, Units( "Minutes"): ToSubclass]
	UINT32 EstimatedRunTime;
		[Description( "Indicates the battery's expected lifetime in minutes, assuming "
				"that the battery is fully charged. This property represents the total expected "
				"life of the battery, not its current remaining life, which is indicated by "
				"the EstimatedRunTime property. "): ToSubclass, DisplayName{ "ExpectedLife"}, 
		PropertySources{ "ExpectedLife"}: ToSubclass, read: ToSubclass, Units( "Minutes"): 
		ToSubclass]
	UINT32 ExpectedLife;
		[Description( "The full charge capacity of the battery in Milliwatt-Hours. Comparison "
				"of this value to the DesignCapacity property determines when the battery "
				"requires replacement.  A battery's end of life is typically when the FullChargeCapacity "
				"property falls below 80% of the DesignCapacity property. If this property "
				"is not supported, enter 0."): ToSubclass, DisplayName{ "FullChargeCapacity"}, 
		MappingStrings{ "MIF.DMTF|Portable Battery|002.11"}: ToSubclass, PropertySources{ 
		"FullChargeCapacity"}: ToSubclass, read: ToSubclass, Units( "Milliwatt-Hours"): 
		ToSubclass]
	UINT32 FullChargeCapacity;
		[Description( "MaxRechargeTime indicates the maximum time, in minutes, to fully "
				"charge the battery. This property represents the time to recharge a fully "
				"depleted battery, not the current remaining charging time, which is indicated "
				"in the TimeToFullCharge property. "): ToSubclass, DisplayName{ "MaxRechargeTime"}, 
		PropertySources{ "MaxRechargeTime"}: ToSubclass, read: ToSubclass, Units( "Minutes"): 
		ToSubclass]
	UINT32 MaxRechargeTime;
		[Description( "The Smart Battery Data Specification version number supported by "
				"this battery. If the battery does not support this function, the value should "
				"be left blank."): ToSubclass, DisplayName{ "SmartBatteryVersion"}, MappingStrings{ 
		"MIF.DMTF|Portable Battery|002.10"}: ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ 
		"SmartBatteryVersion"}: ToSubclass, read: ToSubclass]
	STRING SmartBatteryVersion;
		[Description( "TimeOnBattery indicates the elapsed time in seconds since the computer "
				"system's UPS last switched to battery power, or the time since the system "
				"or UPS was last restarted, whichever is less. Zero shall be returned if the "
				"battery is 'on line'."): ToSubclass, DisplayName{ "TimeOnBattery"}, PropertySources{ 
		"TimeOnBattery"}: ToSubclass, read: ToSubclass, Units( "Seconds"): ToSubclass]
	UINT32 TimeOnBattery;
		[Description( "The remaining time to charge the battery fully in minutes at the "
				"current charging rate and usage."): ToSubclass, DisplayName{ "TimeToFullCharge"}, 
		MappingStrings{ "MIF.DMTF|Portable Battery|002.16"}: ToSubclass, PropertySources{ 
		"TimeToFullCharge"}: ToSubclass, read: ToSubclass, Units( "Minutes"): ToSubclass]
	UINT32 TimeToFullCharge;
};
	[abstract, Description( "CIM_MediaAccessDevice represents the ability to access "
				"one or more media and use this media to store and retrieve data."): ToSubclass, 
		Locale( 1033), UUID( 
		"{8502C52A-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_MediaAccessDevice:CIM_LogicalDevice
{
		[ArrayType( "Indexed"): ToSubclass, Description( "Capabilities of the media access "
				"device.  For example, the device may support \"Random Access\", removable "
				"media and \"Automatic Cleaning\".  In this case, the values 3, 7 and 9 would "
				"be written to the array. /nSeveral of the enumerated values require some "
				"explanation: 1) Value 11, Supports Dual Sided Media, distinguishes a Device "
				"that can access both sides of dual sided Media, from a Device that reads "
				"only a single side and requires the Media to be flipped; and, 2) Value 12, "
				"Predismount Eject Not Required, indicates that Media does not have to be "
				"explicitly ejected from the Device before being accessed by a PickerElement."): 
		ToSubclass, DisplayName{ "Capabilities"}, MappingStrings{ "MIF.DMTF|Storage Devices|001.9", 
		"MIF.DMTF|Storage Devices|001.11", "MIF.DMTF|Storage Devices|001.12", "MIF.DMTF|Disks|003.7"}: 
		ToSubclass, ModelCorrespondence{ "CIM_MediaAccessDevice.CapabilityDescriptions"}: 
		ToSubclass, PropertySources{ "Capabilities"}: ToSubclass, read: ToSubclass, Values{ 
		"Unknown", "Other", "Sequential Access", "Random Access", "Supports Writing", 
		"Encryption", "Compression", "Supports Removeable Media", "Manual Cleaning", 
		"Automatic Cleaning", "SMART Notification", "Supports Dual Sided Media", "Predismount "
				"Eject Not Required"}: ToSubclass]
	UINT16 Capabilities[];
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the access device features "
				"indicated in the Capabilities array. Note, each entry of this array is related "
				"to the entry in the Capabilities array that is located at the same index."): 
		ToSubclass, DisplayName{ "CapabilityDescriptions"}, ModelCorrespondence{ "CIM_MediaAccessDevice.Capabilities"}: 
		ToSubclass, PropertySources{ "CapabilityDescriptions"}: ToSubclass, read: ToSubclass]
	STRING CapabilityDescriptions[];
		[Description( "A free form string indicating the algorithm or tool used by the "
				"device to support compression. If it is not possible or not desired to describe "
				"the compression scheme (perhaps because it is not known), recommend using "
				"the following words: \"Unknown\" to represent that it is not known whether "
				"the device supports compression capabilities or not, \"Compressed\" to represent "
				"that the device supports compression capabilities but either its compression "
				"scheme is not known or not disclosed, and \"Not Compressed\" to represent "
				"that the devices does not support compression capabilities."): ToSubclass, 
		DisplayName{ "CompressionMethod"}, PropertySources{ "CompressionMethod"}: ToSubclass, 
		read: ToSubclass]
	STRING CompressionMethod;
		[Description( "Default block size, in bytes, for this device."): ToSubclass, DisplayName{ 
		"DefaultBlockSize"}, PropertySources{ "DefaultBlockSize"}: ToSubclass, read: 
		ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 DefaultBlockSize;
		[Description( "ErrorMethodology is a free-form string describing the type(s) of "
				"error detection and correction supported by this device."): ToSubclass, DisplayName{ 
		"ErrorMethodology"}, PropertySources{ "ErrorMethodology"}: ToSubclass, read: 
		ToSubclass]
	STRING ErrorMethodology;
		[Description( "Maximum block size, in bytes, for media accessed by this device."): 
		ToSubclass, DisplayName{ "MaxBlockSize"}, PropertySources{ "MaxBlockSize"}: ToSubclass, 
		read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 MaxBlockSize;
		[Description( "Maximum size, in Kbytes, of media supported by this device. KBytes "
				"is interpreted as the number of bytes multiplied by 1000 (NOT the number "
				"of bytes multiplied by 1024)."): ToSubclass, DisplayName{ "MaxMediaSize"}, 
		MappingStrings{ "MIF.DMTF|Sequential Access Devices|001.2"}: ToSubclass, PropertySources{ 
		"MaxMediaSize"}: ToSubclass, read: ToSubclass, Units( "Kilobytes"): ToSubclass]
	UINT64 MaxMediaSize;
		[Description( "Minimum block size, in bytes, for media accessed by this device."): 
		ToSubclass, DisplayName{ "MinBlockSize"}, PropertySources{ "MinBlockSize"}: ToSubclass, 
		read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 MinBlockSize;
		[Description( "Boolean indicating that the media access device needs cleaning. "
				"Whether manual or automatic cleaning is possible is indicated in the Capabilities "
				"array property. "): ToSubclass, DisplayName{ "NeedsCleaning"}, PropertySources{ 
		"NeedsCleaning"}: ToSubclass, read: ToSubclass]
	BOOLEAN NeedsCleaning;
		[Description( "When the media access device supports multiple individual media, "
				"this property defines the maximum number which can be supported or inserted."): 
		ToSubclass, DisplayName{ "NumberOfMediaSupported"}, PropertySources{ "NumberOfMediaSupported"}: 
		ToSubclass, read: ToSubclass]
	UINT32 NumberOfMediaSupported;
};
	[Description( "The CIM_TapeDrive class represents a tape drive on the system. Tape "
				"drives are primarily distinguished by the fact that they can only be accessed "
				"sequentially."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{8502C52D-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_TapeDrive"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_TapeDrive:CIM_MediaAccessDevice
{
		[Description( "EOTWarningZoneSize indicates the size, in bytes, of the area designated "
				"as 'end of tape'. Access in this area generates an 'end of tape' warning."): 
		ToSubclass, DisplayName{ "EOTWarningZoneSize"}, PropertySources{ "EOTWarningZoneSize"}: 
		ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT32 EOTWarningZoneSize;
		[Description( "The MaxPartitionCount property indicates the maximum part count "
				"for the tape drive."): ToSubclass, DisplayName{ "MaxPartitionCount"}, PropertySources{ 
		"MaxPartitionCount"}: ToSubclass, read: ToSubclass]
	UINT32 MaxPartitionCount;
		[Description( "Padding indicates the number of bytes inserted between blocks on "
				"a tape Media."): ToSubclass, DisplayName{ "Padding"}, PropertySources{ "Padding"}: 
		ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT32 Padding;
};
	[Description( "The CIM_CDROMDrive class represents a CD-ROM drive on the system./n<B>Note:</B> "
				"The name of the drive does not correspond to the logical drive letter assigned "
				"to device, which is the name of the logical storage device dependent on this "
				"drive."): ToSubclass, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{8502C52B-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_CDROMDrive"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_CDROMDrive:CIM_MediaAccessDevice
{
};
	[Description( "The CIM_DiskDrive class represents a physical disk drive as seen "
				"by the operating system. The features of the drive seen through this object "
				"correspond to the logical and management characteristics of the drive and, "
				"in some cases may not reflect the actual physical characteristics of the "
				"device. Any interface to a physical drive is a member of this class. Any "
				"object based on another logical device would not be a member of this class./nExample: "
				"IDE Fixed Disk."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{8502C52C-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_DiskDrive"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DiskDrive:CIM_MediaAccessDevice
{
};
	[abstract, Description( "Capabilities and management  of a magneto-optical drive, "
				"a subtype of media access device."): ToSubclass, Locale( 1033), UUID( "{F62037D8-E3D0-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_MagnetoOpticalDrive:CIM_MediaAccessDevice
{
};
	[Description( "Capabilities and management of a diskette drive, a subtype of CIM_MediaAccessDevice."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{F27851CD-BBAC-11d2-85E5-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_DisketteDrive"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DisketteDrive:CIM_MediaAccessDevice
{
};
	[abstract, Description( "Capabilities and management  of a WORM drive, a subtype "
				"of media access device."): ToSubclass, Locale( 1033), UUID( "{FFB58B9A-E3D0-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_WORMDrive:CIM_MediaAccessDevice
{
};
	[abstract, Description( "Capabilities and management of the power supply logical "
				"device."): ToSubclass, 
		Locale( 1033), UUID( "{8502C547-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_PowerSupply:CIM_LogicalDevice
{
		[Description( "ActiveInputVoltage indicates which input voltage range is currently "
				"in use. Range 1, 2 or both can be specified using the values 3, 4 or 5, respectively. "
				"If the Supply is not currently drawing power, the value 6 (\"Neither\") can "
				"be specified. This information is necessary in the case of a UPS, a subclass "
				"of PowerSupply."): ToSubclass, DisplayName{ "ActiveInputVoltage"}, MappingStrings{ 
		"MIF.DMTF|Power Supply|002.15"}: ToSubclass, PropertySources{ "ActiveInputVoltage"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6"}: ToSubclass, 
		Values{ "Other", "Unknown", "Range 1", "Range 2", "Both", "Neither"}: ToSubclass]
	UINT16 ActiveInputVoltage;
		[Description( "Boolean indicating that the power supply is a switching (vs. linear) "
				"supply."): ToSubclass, DisplayName{ "IsSwitchingSupply"}, PropertySources{ 
		"IsSwitchingSupply"}: ToSubclass, read: ToSubclass]
	BOOLEAN IsSwitchingSupply;
		[Description( "The frequency (in Hertz) at the high end of this powersupply's "
				"input frequency range 1. A value of zero implies DC."): ToSubclass, DisplayName{ 
		"Range1InputFrequencyHigh"}, PropertySources{ "Range1InputFrequencyHigh"}: ToSubclass, 
		read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 Range1InputFrequencyHigh;
		[Description( "The frequency (in Hertz) at the low end of this powersupply's input "
				"frequency range 1. A value of zero implies DC."): ToSubclass, DisplayName{ 
		"Range1InputFrequencyLow"}, MappingStrings{ "MIF.DMTF|Power Supply|002.17"}: 
		ToSubclass, PropertySources{ "Range1InputFrequencyLow"}: ToSubclass, read: ToSubclass, 
		Units( "Hertz"): ToSubclass]
	UINT32 Range1InputFrequencyLow;
		[Description( "The high voltage of input voltage range 1 for this power supply, "
				"in Millivolts. A value of 0 denotes 'unknown'."): ToSubclass, DisplayName{ 
		"Range1InputVoltageHigh"}, MappingStrings{ "MIF.DMTF|Power Supply|002.8"}: ToSubclass, 
		PropertySources{ "Range1InputVoltageHigh"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range1InputVoltageHigh;
		[Description( "The low voltage of input voltage range 1 for this power supply, "
				"in Millivolts. A value of 0 denotes 'unknown'."): ToSubclass, DisplayName{ 
		"Range1InputVoltageLow"}, MappingStrings{ "MIF.DMTF|Power Supply|002.7"}: ToSubclass, 
		PropertySources{ "Range1InputVoltageLow"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range1InputVoltageLow;
		[Description( "The frequency (in Hertz) at the high end of this powersupply's "
				"input frequency range 2. A value of zero implies DC."): ToSubclass, DisplayName{ 
		"Range2InputFrequencyHigh"}, MappingStrings{ "MIF.DMTF|Power Supply|002.20"}: 
		ToSubclass, PropertySources{ "Range2InputFrequencyHigh"}: ToSubclass, read: ToSubclass, 
		Units( "Hertz"): ToSubclass]
	UINT32 Range2InputFrequencyHigh;
		[Description( "The frequency (in Hertz) at the low end of this powersupply's input "
				"frequency range 2. A value of zero implies DC."): ToSubclass, DisplayName{ 
		"Range2InputFrequencyLow"}, MappingStrings{ "MIF.DMTF|Power Supply|002.19"}: 
		ToSubclass, PropertySources{ "Range2InputFrequencyLow"}: ToSubclass, read: ToSubclass, 
		Units( "Hertz"): ToSubclass]
	UINT32 Range2InputFrequencyLow;
		[Description( "The high voltage of input voltage range 2 for this power supply, "
				"in Millivolts. A value of 0 denotes 'unknown'."): ToSubclass, DisplayName{ 
		"Range2InputVoltageHigh"}, MappingStrings{ "MIF.DMTF|Power Supply|002.12"}: ToSubclass, 
		PropertySources{ "Range2InputVoltageHigh"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range2InputVoltageHigh;
		[Description( "The low voltage of input voltage range 2 for this power supply, "
				"in Millivolts. A value of 0 denotes 'unknown'."): ToSubclass, DisplayName{ 
		"Range2InputVoltageLow"}, MappingStrings{ "MIF.DMTF|Power Supply|002.11"}: ToSubclass, 
		PropertySources{ "Range2InputVoltageLow"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range2InputVoltageLow;
		[Description( "Represents the total output power of the power supply in Milliwatts. "
				"0 denotes 'unknown'."): ToSubclass, DisplayName{ "TotalOutputPower"}, MappingStrings{ 
		"MIF.DMTF|Power Supply|002.21"}: ToSubclass, PropertySources{ "TotalOutputPower"}: 
		ToSubclass, read: ToSubclass, Units( "Milliwatts"): ToSubclass]
	UINT32 TotalOutputPower;
		[Description( "TypeOfRangeSwitching describes the kind of input voltage range "
				"switching implemented in this power supply. For example, Autoswitch can be "
				"specified (value=4)."): ToSubclass, DisplayName{ "TypeOfRangeSwitching"}, 
		MappingStrings{ "MIF.DMTF|Power Supply|002.16"}: ToSubclass, PropertySources{ 
		"TypeOfRangeSwitching"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", 
		"4", "5", "6"}: ToSubclass, Values{ "Other", "Unknown", "Manual", "Autoswitch", 
		"Wide Range", "Not Applicable"}: ToSubclass]
	UINT16 TypeOfRangeSwitching;
};
	[Description( "Capabilities and management of an uninterruptible power supply. "
				"The properties of the UPS device indicate when incoming power is trimmed "
				"or boosted, and the aggregated information of the batteries, generators, "
				"etc. that comprise the device.  These individual components (for example, "
				"multiple batteries) can also be independently modeled and associated with "
				"the UPS."): ToSubclass, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{8502C54F-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_UninterruptiblePowerSupply"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_UninterruptiblePowerSupply:CIM_PowerSupply
{
		[Description( "An estimate of the percentage of full charge remaining for a UPS "
				"(that uses battery technology)."): ToSubclass, DisplayName{ "EstimatedChargeRemaining"}, 
		MappingStrings{ "MIF.DMTF|UPS Battery|001.4"}: ToSubclass, PropertySources{ "EstimatedChargeRemaining"}: 
		ToSubclass, read: ToSubclass, Units( "Percent"): ToSubclass]
	UINT16 EstimatedChargeRemaining;
		[Description( "EstimatedRunTime is an estimate in minutes of the time to battery, "
				"generator, ... depletion under the present load conditions if the utility "
				"power is off, or lost and remains off."): ToSubclass, DisplayName{ "EstimatedRunTime"}, 
		MappingStrings{ "MIF.DMTF|UPS Battery|001.3"}: ToSubclass, PropertySources{ "EstimatedRunTime"}: 
		ToSubclass, read: ToSubclass, Units( "Minutes"): ToSubclass]
	UINT32 EstimatedRunTime;
		[Description( "If the voltage (in Millivolts) rises above the value specified "
				"by Range1InputVoltageHigh property, the UPS will compensate by trimming the "
				"voltage.  A value of 0 indicates that the voltage at which trimming occurs "
				"is 'unknown'."): ToSubclass, DisplayName{ "Range1InputVoltageHigh"}, MappingStrings{ 
		"MIF.DMTF|Power Supply|002.8"}: ToSubclass, Override( "Range1InputVoltageHigh"), 
		PropertySources{ "Range1InputVoltageHigh"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range1InputVoltageHigh;
		[Description( "If the voltage (in Millivolts) drops below the value specified "
				"by Range1InputVoltageLow property, the UPS will compensate by boosting the "
				"voltage using its power source(s).  A value of 0 indicates that the voltage "
				"at which boosting occurs is 'unknown'."): ToSubclass, DisplayName{ "Range1InputVoltageLow"}, 
		MappingStrings{ "MIF.DMTF|Power Supply|002.7"}: ToSubclass, Override( "Range1InputVoltageLow"), 
		PropertySources{ "Range1InputVoltageLow"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range1InputVoltageLow;
		[Description( "If the voltage (in Millivolts) rises above the value specified "
				"by Range2InputVoltageHigh property, the UPS will compensate by trimming the "
				"voltage.  A value of 0 indicates that the voltage at which trimming occurs "
				"is 'unknown'."): ToSubclass, DisplayName{ "Range2InputVoltageHigh"}, MappingStrings{ 
		"MIF.DMTF|Power Supply|002.12"}: ToSubclass, Override( "Range2InputVoltageHigh"), 
		PropertySources{ "Range2InputVoltageHigh"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range2InputVoltageHigh;
		[Description( "If the voltage (in Millivolts) drops below the value specified "
				"by Range2InputVoltageLow property, the UPS will compensate by boosting the "
				"voltage using its power source(s).  A value of 0 indicates that the voltage "
				"at which boosting occurs is 'unknown'."): ToSubclass, DisplayName{ "Range2InputVoltageLow"}, 
		MappingStrings{ "MIF.DMTF|Power Supply|002.11"}: ToSubclass, Override( "Range2InputVoltageLow"), 
		PropertySources{ "Range2InputVoltageLow"}: ToSubclass, read: ToSubclass, Units( 
		"Millivolts"): ToSubclass]
	UINT32 Range2InputVoltageLow;
		[Description( "The indication of the capacity remaining in the UPS' batteries, "
				"generator, ...  A value of \"Normal\" (2) indicates that the remaining estimated "
				"minutes of run-time is greater than the UPS' defined 'low power' state (typically "
				"two minutes). A value of \"Low\" (3) indicates that the remaining estimated "
				"minutes of run-time is less than or equal to the UPS' defined 'low power' "
				"state.  A value of \"Depleted\" (4) indicates that the UPS will be unable "
				"to sustain the present load when and if the utility power is lost (including "
				"the possibility that the utility power is currently absent)."): ToSubclass, 
		DisplayName{ "RemainingCapacityStatus"}, MappingStrings{ "MIF.DMTF|UPS Battery|001.1"}: 
		ToSubclass, PropertySources{ "RemainingCapacityStatus"}: ToSubclass, read: ToSubclass, 
		ValueMap{ "1", "2", "3", "4"}: ToSubclass, Values{ "Unknown", "Normal", "Low", 
		"Depleted"}: ToSubclass]
	UINT16 RemainingCapacityStatus;
		[Description( "TimeOnBackup indicates the elapsed time in seconds since the UPS "
				"last switched to battery power, generator, ...  Or, the time since the UPS "
				"was last restarted, whichever is less. Zero shall be returned if the UPS "
				"is 'on line'."): ToSubclass, DisplayName{ "TimeOnBackup"}, MappingStrings{ 
		"MIF.DMTF|UPS Battery|001.2"}: ToSubclass, PropertySources{ "TimeOnBackup"}: 
		ToSubclass, read: ToSubclass, Units( "Seconds"): ToSubclass]
	UINT32 TimeOnBackup;
};
	[Description( "An operating system is software/firmware that makes a computer system's "
				"hardware usable, and implements and/or manages the resources, file systems, "
				"processes, user interfaces, services, ... available on the computer system."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C565-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_OperatingSystem"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_OperatingSystem:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "CSCreationClassName contains the scoping computer system's creation "
				"class name."): ToSubclass, DisplayName{ "CSCreationClassName"}, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_ComputerSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "CSName contains the scoping computer system's name."): ToSubclass, 
		DisplayName{ "CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_ComputerSystem.Name"): ToSubclass, PropertySources{ 
		"CSName"}: ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "CurrentTimeZone indicates the number of minutes the operating system "
				"is offset from Greenwich Mean Time. Either the number is positive, negative "
				"or zero."): ToSubclass, DisplayName{ "CurrentTimeZone"}, PropertySources{ 
		"CurrentTimeZone"}: ToSubclass, read: ToSubclass, Units( "Minutes"): ToSubclass, 
		write: ToSubclass]
	SINT16 CurrentTimeZone;
		[Description( "Boolean indicating whether the operating system is distributed "
				"across several computer system nodes. If so, these nodes should be grouped "
				"as a cluster."): ToSubclass, DisplayName{ "Distributed"}, PropertySources{ 
		"Distributed"}: ToSubclass, read: ToSubclass]
	BOOLEAN Distributed;
		[Description( "Number of kilobytes of physical memory currently unused and available"): 
		ToSubclass, DisplayName{ "FreePhysicalMemory"}, PropertySources{ "FreePhysicalMemory"}: 
		ToSubclass, read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT64 FreePhysicalMemory;
		[Description( "The total number of KBytes that can be mapped into the OperatingSystem's "
				"paging files without causing any other pages to be swapped out. 0 indicates "
				"that there are no paging files."): ToSubclass, DisplayName{ "FreeSpaceInPagingFiles"}, 
		MappingStrings{ "MIF.DMTF|System Memory Settings|001.4"}: ToSubclass, PropertySources{ 
		"FreeSpaceInPagingFiles"}: ToSubclass, read: ToSubclass, Units( "KiloBytes"): 
		ToSubclass]
	UINT64 FreeSpaceInPagingFiles;
		[Description( "Number of kilobytes of virtual memory currently unused and available. "
				"For example, this may be calculated by adding the amount of free RAM to the "
				"amount of free paging space (i.e., adding the properties, FreePhysicalMemory "
				"and FreeSpaceInPagingFiles)."): ToSubclass, DisplayName{ "FreeVirtualMemory"}, 
		PropertySources{ "FreeVirtualMemory"}: ToSubclass, read: ToSubclass, Units( "KiloBytes"): 
		ToSubclass]
	UINT64 FreeVirtualMemory;
		[Description( "Time when the operating system was last booted"): ToSubclass, DisplayName{ 
		"LastBootUpTime"}, PropertySources{ "LastBootUpTime"}: ToSubclass, read: ToSubclass]
	DATETIME LastBootUpTime;
		[Description( "Operating system's notion of the local date and time of day."): 
		ToSubclass, DisplayName{ "LocalDateTime"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrSystemDate", 
		"MIF.DMTF|General Information|001.6"}: ToSubclass, PropertySources{ "LocalDateTime"}: 
		ToSubclass, read: ToSubclass]
	DATETIME LocalDateTime;
		[Description( "Maximum number of process contexts the operating system can support. "
				"If there is no fixed maximum, the value should be 0. On systems that have "
				"a fixed maximum, this object can help diagnose failures that occur when the "
				"maximum is reached. If unknown, enter -1."): ToSubclass, DisplayName{ "MaxNumberOfProcesses"}, 
		MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrSystemMaxProcesses"}: ToSubclass, 
		PropertySources{ "MaxNumberOfProcesses"}: ToSubclass, read: ToSubclass]
	UINT32 MaxNumberOfProcesses;
		[Description( "Maximum number of kilobytes of memory that can be allocated to "
				"a process. For operating systems with no virtual memory, this value is typically "
				"equal to the total amount of physical memory minus memory used by the BIOS "
				"and OS. For some operating systems, this value may be infinity - in which "
				"case, 0 should be entered. In other cases, this value could be a constant "
				"- for example, 2G or 4G."): ToSubclass, DisplayName{ "MaxProcessMemorySize"}, 
		PropertySources{ "MaxProcessMemorySize"}: ToSubclass, read: ToSubclass, Units( 
		"KiloBytes"): ToSubclass]
	UINT64 MaxProcessMemorySize;
		[Description( "The inherited Name property serves as key of an operating system "
				"instance within a computer system."): ToSubclass, DisplayName( "Name"): ToInstance 
		 ToSubclass, key: DisableOverride  ToInstance  ToSubclass, Override( "Name"), 
		PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "Number of user licenses for the operating system. If unlimited, "
				"enter 0. If unknown, enter -1."): ToSubclass, DisplayName{ "NumberOfLicensedUsers"}, 
		PropertySources{ "NumberOfLicensedUsers"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfLicensedUsers;
		[Description( "Number of process contexts currently loaded or running on the operating "
				"system."): ToSubclass, DisplayName{ "NumberOfProcesses"}, MappingStrings{ 
		"MIB.IETF|HOST-RESOURCES-MIB.hrSystemProcesses"}: ToSubclass, PropertySources{ 
		"NumberOfProcesses"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfProcesses;
		[Description( "Number of user sessions for which the operating system is currently "
				"storing state information"): ToSubclass, DisplayName{ "NumberOfUsers"}, MappingStrings{ 
		"MIB.IETF|HOST-RESOURCES-MIB.hrSystemNumUsers"}: ToSubclass, PropertySources{ 
		"NumberOfUsers"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfUsers;
		[Description( "A integer indicating the type of operating system."): ToSubclass, 
		DisplayName{ "OSType"}, ModelCorrespondence{ "CIM_OperatingSystem.OtherTypeDescription"}: 
		ToSubclass, PropertySources{ "OSType"}: ToSubclass, read: ToSubclass, Values{ 
		"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", "OpenVMS", 
		"HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", 
		"WINNT", "WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO "
				"UnixWare", "SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000", 
		"ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", 
		"Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH "
				"Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", 
		"HP MPE", "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "OS/390", 
		"VSE", "TPF"}: ToSubclass]
	UINT16 OSType;
		[Description( "A string describing the manufacturer and operating system type "
				"- used when the operating system property, OSType, is set to 1 (\"Other\"). "
				"The format of the string inserted in OtherTypeDescription should be similar "
				"in format to the Values strings defined for OSType.  OtherTypeDescription "
				"should be set to NULL when OSType is any value other than 1."): ToSubclass, 
		DisplayName{ "OtherTypeDescription"}, MaxLen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_OperatingSystem.OSType"}: ToSubclass, PropertySources{ "OtherTypeDescription"}: 
		ToSubclass, read: ToSubclass]
	STRING OtherTypeDescription;
		[Description( "The total number of kilobytes that can be stored in the operating "
				"system's paging files. Note that this number does not represent the actual "
				"physical size of the paging file on disk.  0 indicates that there are no "
				"paging files."): ToSubclass, DisplayName{ "SizeStoredInPagingFiles"}, MappingStrings{ 
		"MIF.DMTF|System Memory Settings|001.3"}: ToSubclass, PropertySources{ "SizeStoredInPagingFiles"}: 
		ToSubclass, read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT64 SizeStoredInPagingFiles;
		[Description( "Total swap space in kilobytes. This value may be NULL (unspecified) "
				"if swap space is not distinguished from page files.  However, some operating "
				"systems distinguish these concepts.  For example, in UNIX, whole processes "
				"can be 'swapped out' when the free page list falls and remains below a specified "
				"amount."): ToSubclass, DisplayName{ "TotalSwapSpaceSize"}, PropertySources{ 
		"TotalSwapSpaceSize"}: ToSubclass, read: ToSubclass, Units( "KiloBytes"): ToSubclass]
	UINT64 TotalSwapSpaceSize;
		[Description( "Number of kilobytes of virtual memory. For example, this may be "
				"calculated by adding the amount of total RAM to the amount of paging space "
				"(i.e., adding the amount of memory in/aggregated by the computer system to "
				"the property, SizeStoredInPagingFiles."): ToSubclass, DisplayName{ "TotalVirtualMemorySize"}, 
		PropertySources{ "TotalVirtualMemorySize"}: ToSubclass, read: ToSubclass, Units( 
		"KiloBytes"): ToSubclass]
	UINT64 TotalVirtualMemorySize;
		[Description( "The total amount of physical memory (in Kbytes) available to the "
				"OperatingSystem. This value does not necessarily indicate the true amount "
				"of physical memory, but what is reported to the OperatingSystem as available "
				"to it."): ToSubclass, DisplayName{ "TotalVisibleMemorySize"}, PropertySources{ 
		"TotalVisibleMemorySize"}: ToSubclass, read: ToSubclass, Units( "KiloBytes"): 
		ToSubclass]
	UINT64 TotalVisibleMemorySize;
		[Description( "A string describing the operating system's version number. The "
				"format of the version information is as follows: <Major Number>.<Minor Number>.<Revision> "
				"or <Major Number>.<Minor Number>.<Revision Letter>."): ToSubclass, DisplayName{ 
		"Version"}, MappingStrings{ "MIF.DMTF|Operating System|001.3"}: ToSubclass, PropertySources{ 
		"Version"}: ToSubclass, read: ToSubclass]
	STRING Version;
		[Description( "Requests a reboot of the operating system. The return value should "
				"be 0 if the request was successfully executed, 1 if the request is not supported "
				"and some other value if an error occurred.  The strings to which the ValueMap "
				"contents are 'translated' may also be specified in the subclass as a Values "
				"array qualifier."): ToSubclass, DisplayName{ "Reboot"}, MethodSource{ "Reboot"}]
	UINT32 Reboot();
		[Description( "Requests a shutdown of the operating system. The return value should "
				"be 0 if the request was successfully executed, 1 if the request is not supported "
				"and some other value if an error occurred. It is up to the implementation "
				"or subclass of operating system to establish dependencies between the Shutdown "
				"and Reboot methods, and for example, to provide more sophisticated capabilities "
				"such as scheduled shutdown/reboot, etc."): ToSubclass, DisplayName{ "Shutdown"}, 
		MethodSource{ "Shutdown"}]
	UINT32 Shutdown();
};
	[Description( "Each instance of the CIM_Process class represents a single instance "
				"of a running program. A user of the OperatingSystem will typically see a "
				"Process as an application or task. Within an OperatingSystem, a Process is "
				"defined by a workspace of memory resources and environmental settings that "
				"are allocated to it. On a multitasking System, this workspace prevents intrusion "
				"of resources by other Processes. Additionally, a Process can execute as multiple "
				"Threads, all which run within the same workspace."): ToSubclass, 
		DisplayName("Processes (CIM)"): ToInstance  ToSubclass, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{8502C566-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Process"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Process:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName( "Class Name"): ToInstance 
		 ToSubclass, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		PropertySources{ "CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "Time that the process began executing."): ToSubclass, DisplayName( 
		"Creation Date"): ToInstance  ToSubclass, PropertySources{ "CreationDate"}: ToSubclass, 
		read: ToSubclass]
	DATETIME CreationDate;
		[Description( "CSCreationClassName contains the scoping computer system's creation "
				"class name."): ToSubclass, DisplayName( "Computer System Class Name"): ToInstance 
		 ToSubclass, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_OperatingSystem.CSCreationClassName"): ToSubclass, PropertySources{ 
		"CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The scoping computer system's name."): ToSubclass, DisplayName( 
		"Computer System Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_OperatingSystem.CSName"): 
		ToSubclass, PropertySources{ "CSName"}: ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "Indicates the current operating condition of the process. Values "
				"include ready (2), running (3), and blocked (4), among others."): ToSubclass, 
		DisplayName( "Execution State"): ToInstance  ToSubclass, PropertySources{ "ExecutionState"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Ready", "Running", 
		"Blocked", "Suspended Blocked", "Suspended Ready", "Terminated", "Stopped", "Growing"}: 
		ToSubclass]
	UINT16 ExecutionState;
		[Description( "A string used to identify the process. A process ID is a kind of "
				"process handle."): ToSubclass, DisplayName( "Handle"): ToInstance  ToSubclass, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"Handle"}: ToSubclass, read: ToSubclass]
	STRING Handle;
		[Description( "Time in kernel mode, in milliseconds. If this information is not "
				"available, a value of 0 should be used."): ToSubclass, DisplayName( "Kernel "
				"Model Time"): ToInstance  ToSubclass, PropertySources{ "KernelModeTime"}: 
		ToSubclass, read: ToSubclass, Units( "Milliseconds"): ToSubclass]
	UINT64 KernelModeTime;
		[Description( "The scoping operating system's creation class name."): ToSubclass, 
		DisplayName( "Operating System Class Name"): ToInstance  ToSubclass, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_OperatingSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "OSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING OSCreationClassName;
		[Description( "The scoping operating system's name."): ToSubclass, DisplayName( 
		"Operating System Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Propagated( "CIM_OperatingSystem.Name"): 
		ToSubclass, PropertySources{ "OSName"}: ToSubclass, read: ToSubclass]
	STRING OSName;
		[Description( "Priority indicates the urgency or importance of execution of a "
				"process. If a priority is not defined for a process, a value of 0 should "
				"be used."): ToSubclass, DisplayName( "Priority"): ToInstance  ToSubclass, 
		PropertySources{ "Priority"}: ToSubclass, read: ToSubclass]
	UINT32 Priority;
		[Description( "Time that the process was stopped or terminated."): ToSubclass, 
		DisplayName( "Termination Date"): ToInstance  ToSubclass, PropertySources{ "TerminationDate"}: 
		ToSubclass, read: ToSubclass]
	DATETIME TerminationDate;
		[Description( "Time in user mode, in milliseconds. If this information is not "
				"available, a value of 0 should be used."): ToSubclass, DisplayName( "User "
				"Mode Time"): ToInstance  ToSubclass, PropertySources{ "UserModeTime"}: ToSubclass, 
		read: ToSubclass, Units( "Milliseconds"): ToSubclass]
	UINT64 UserModeTime;
		[Description( "The amount of memory in bytes that a process needs to execute efficiently, "
				"for an operating system that uses page-based memory management. If an insufficient "
				"amount of memory is available (< working set size), thrashing will occur. "
				"If this information is not known, NULL or 0 should be entered.  If this data "
				"is provided, it could be monitored to understand a process' changing memory "
				"requirements as execution proceeds."): ToSubclass, DisplayName( "Working "
				"Set Size"): ToInstance  ToSubclass, PropertySources{ "WorkingSetSize"}: ToSubclass, 
		read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 WorkingSetSize;
};
	[Description( " The CIM_SoftwareFeature class defines a particular function  or "
				"capability of a product or application system.  This  class in intended to "
				"capture the level of granularity that  is meaningful to a consumer or user "
				"of a product rather than  the units that reflect how the product is built "
				"or packaged.  The latter detailed is captured using a CIM_SoftwareElement "
				" class.   When a software feature can exist on multiple platforms or  operating "
				"systems (for example, a client component of a  three tiered client/server "
				"applications might run on Solaris,  Windows NT, and Windows 95), a software "
				"feature is a collection  of all the software elements for these different "
				"platforms.  In this case, the users of the model must be aware of this situation "
				" since typically they will be interested in a sub-collection of the  software "
				"elements required for a particular platform.   Software features are always "
				"defined in the context of a  CIM_Product class using the CIM_ProductSoftwareFeatures "
				" association since features are delivered through products.  Optionally, "
				"software features from one or more products  can be organized into application "
				"systems using the  CIM_ApplicationSystemSoftwareFeature association.  "): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{E527D7F2-E3D4-11d2-8601-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_SoftwareFeature"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SoftwareFeature:CIM_LogicalElement
{
		[Description( "Product identification such as a serial number on software or a "
				"die number on a hardware chip"): ToSubclass, DisplayName{ "IdentifyingNumber"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "DMTF|ComponentID|001.4"}: 
		ToSubclass, Maxlen( 64): ToSubclass, Propagated( "CIM_Product.IdentifyingNumber"): 
		ToSubclass, PropertySources{ "IdentifyingNumber"}: ToSubclass, read: ToSubclass]
	STRING IdentifyingNumber;
		[Description( "The Name property defines the label by which the object is known "
				"to the world outside the data processing system. This label is a human-readable "
				"name that uniquely identifies the element in the context of the element's "
				"namespace."): ToSubclass, DisplayName( "Name"): ToInstance  ToSubclass, key: 
		DisableOverride  ToInstance  ToSubclass, Maxlen( 256): ToSubclass, override( 
		"Name"), PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "Commonly used product name"): ToSubclass, DisplayName{ "ProductName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "DMTF|ComponentID|001.2"}: 
		ToSubclass, Maxlen( 256): ToSubclass, Propagated( "CIM_Product.Name"): ToSubclass, 
		PropertySources{ "ProductName"}: ToSubclass, read: ToSubclass]
	STRING ProductName;
		[Description( "The name of the product's supplier. Corresponds to the Vendor property "
				"in the product object in the DMTF Solution Exchange Standard."): ToSubclass, 
		DisplayName{ "Vendor"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"DMTF|ComponentID|001.1"}: ToSubclass, Maxlen( 256): ToSubclass, Propagated( 
		"CIM_Product.Vendor"): ToSubclass, PropertySources{ "Vendor"}: ToSubclass, read: 
		ToSubclass]
	STRING Vendor;
		[Description( "Product version information.  Corresponds to the Version property "
				"in the product object in the DMTF Solution Exchange Standard."): ToSubclass, 
		DisplayName{ "Version"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"DMTF|ComponentID|001.3"}: ToSubclass, Maxlen( 64): ToSubclass, Propagated( "CIM_Product.Version"): 
		ToSubclass, PropertySources{ "Version"}: ToSubclass, read: ToSubclass]
	STRING Version;
};
	[abstract, Description( "A class derived from CIM_LogicalElement that is a special "
				"collection of managed system elements. This collection indicates that the "
				"aggregated components together provide redundancy. All elements aggregated "
				"in a redundancy group should be instantiations of the same object class."): 
		ToSubclass, Locale( 
		1033), UUID( "{4C3A040A-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_RedundancyGroup:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "RedundancyStatus provides information on the state of the redundancy "
				"group. \"Fully Redundant\" (value=2) means that all of the configured redundancy "
				"is still available; \"Degraded Redundancy\" (3) means that some failures "
				"have been experienced but some reduced amount of redundancy is still available; "
				"\"Redundancy Lost\" (4) means that a sufficient number of failures have been "
				"experienced such that no redundancy is available and the next failure experienced "
				"will cause overall failure. Also, the values, \"Other\" (1) and \"Unknown\" "
				"(0), are defined."): ToSubclass, DisplayName{ "RedundancyStatus"}, PropertySources{ 
		"RedundancyStatus"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Fully Redundant", "Degraded Redundancy", "Redundancy Lost"}: ToSubclass]
	UINT16 RedundancyStatus;
};
	[abstract, Description( "A class derived from RedundancyGroup indicating that one "
				"or more of the aggregated elements can be spared. (The actual Spares are "
				"defined using the ActsAsSpare association.) An example is the use of redundant "
				"NICs in a ComputerSystem - where one NIC is primary and the other is Spare. "
				"The 'primary' NIC would be a member of the SpareGroup (associated using the "
				"RedundancyComponent class) and the 'other' NIC would be associated using "
				"the ActsAsSpare relationship."): ToSubclass, Locale( 1033), 
				UUID( "{64B86CA6-E3D1-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_SpareGroup:CIM_RedundancyGroup
{
};
	[abstract, Description( "A class derived from redundancy group indicating that "
				"the aggregated elements have more capacity or capability than is needed. "
				" An example of this type of redundancy is the installation of N+1 power supplies "
				"or fans in a system."): ToSubclass, Locale( 1033), UUID( "{570ED2E8-E3D1-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ExtraCapacityGroup:CIM_RedundancyGroup
{
		[Description( "MinNumberNeeded indicates the smallest number of elements that "
				"must be operational in order to have redundancy.  For example, in an N+1 "
				"redundancy relationship, the MinNumberNeeded property should be set equal "
				"to N."): ToSubclass, DisplayName{ "MinNumberNeeded"}, PropertySources{ "MinNumberNeeded"}: 
		ToSubclass, read: ToSubclass]
	UINT32 MinNumberNeeded;
};
	[abstract, Description( "A class derived from redundancy group containing mass "
				"storage-related redundancy information. Storage redundancy groups are used "
				"to protect user data.  They are made up of one or more physical extents, "
				"or one or more aggregate physical extents. Storage redundancy groups may "
				"overlap.  However, the underlying extents within the overlap should not contain "
				"any check data."): ToSubclass, Locale( 1033), UUID( "{6D477DBC-E3D1-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_StorageRedundancyGroup:CIM_RedundancyGroup
{
		[Description( "The TypeOfAlgorithm specifies the algorithm used for data redundancy "
				"and reconstruction. For example, \"P+Q\" (value=5) or \"P+S\" (7) may be "
				"specified. The value, 0, is not valid in the CIM Schema since in DMI it represents "
				"that no redundancy exists.  In this case, the object should not be instantiated."): 
		ToSubclass, DisplayName{ "TypeOfAlgorithm"}, MappingStrings{ "MIF.DMTF|Redundancy "
				"Group|001.2"}: ToSubclass, PropertySources{ "TypeOfAlgorithm"}: ToSubclass, 
		read: ToSubclass, Values{ "Undefined", "Other", "Unknown", "Copy", "XOR", "P+Q", 
		"S", "P+S"}: ToSubclass]
	UINT16 TypeOfAlgorithm;
};
	[Description( " The CIM_SoftwareElement class is used to decompose  a CIM_SoftwareFeature "
				"object into a set of individually  manageable or deployable parts for a particular "
				"platform.   A software element's platform is uniquely identified by its  "
				"underlying hardware architecture and operating system  (for example Sun Solaris "
				"on Sun Sparc or Windows NT on Intel).   As such, to understand the details "
				"of how the functionality  of a particular software feature is provided on "
				"a particular  platform, the CIM_SoftwareElement objects referenced by   CIM_SoftwareFeatureSoftwareElement "
				"associations are organized   in disjoint sets based on the TargetOperatingSystem "
				"property.    A CIM_SoftwareElement object captures the management  details "
				"of a part or component in one of  four states  characterized by the SoftwareElementState "
				"property.   "): ToSubclass,  dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{8502C561-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_SoftwareElement"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SoftwareElement:CIM_LogicalElement
{
		[Description( "The internal identifier for this compilation of this software element."): 
		ToSubclass, DisplayName{ "BuildNumber"}, Mappingstrings{ "MIF.DMTF|Software Component "
				"Information|002.4"}: ToSubclass, Maxlen( 64): ToSubclass, PropertySources{ 
		"BuildNumber"}: ToSubclass, read: ToSubclass]
	STRING BuildNumber;
		[Description( "The code set used by this software element. "): ToSubclass, DisplayName{ 
		"CodeSet"}, Maxlen( 64): ToSubclass, PropertySources{ "CodeSet"}: ToSubclass, 
		read: ToSubclass]
	STRING CodeSet;
		[Description( " The value of this property is the manufacturer's identifier for "
				"this software element. Often this will be a stock keeping unit (SKU) or a "
				"part number."): ToSubclass, DisplayName{ "IdentificationCode"}, Mappingstrings{ 
		"MIF.DMTF|Software Component Information|002.7"}: ToSubclass, Maxlen( 64): ToSubclass, 
		PropertySources{ "IdentificationCode"}: ToSubclass, read: ToSubclass]
	STRING IdentificationCode;
		[Description( "The value of this property identifies the language edition of this "
				"software element. The language codes defined in ISO 639 should be used. Where "
				"the software element represents multi-lingual or international version of "
				"a product, the string multilingual should be used."): ToSubclass, DisplayName{ 
		"LanguageEdition"}, Mappingstrings{ "MIF.DMTF|Software Component Information|002.6"}: 
		ToSubclass, Maxlen( 32): ToSubclass, PropertySources{ "LanguageEdition"}: ToSubclass, 
		read: ToSubclass]
	STRING LanguageEdition;
		[Description( "Manufacturer of this software element"): ToSubclass, DisplayName{ 
		"Manufacturer"}, Mappingstrings{ "MIF.DMTF|ComponentID|001.1"}: ToSubclass, Maxlen( 
		256): ToSubclass, PropertySources{ "Manufacturer"}: ToSubclass, read: ToSubclass]
	STRING Manufacturer;
		[Description( "The name used to identify this software element"): ToSubclass, 
		DisplayName( "Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, maxlen( 256): ToSubclass, override( "Name"), PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( " The OtherTargetOS property records the manufacturer and  operating "
				"system type for a software element when  the TargetOperatingSystem property "
				"has a value of  1 (\"Other\").  Therefore, when the TargetOperatingSystem "
				"property has a value of \"Other\", the OtherTargetOS  property must have "
				"a non-null value.  For all other values  of TargetOperatingSystem, the OtherTargetOS "
				"property is to be NULL. "): ToSubclass, DisplayName{ "OtherTargetOS"}, Maxlen( 
		64): ToSubclass, ModelCorrespondence( "CIM_OperatingSystem.OtherTypeDescription"): 
		ToSubclass, PropertySources{ "OtherTargetOS"}: ToSubclass, read: ToSubclass]
	STRING OtherTargetOS;
		[Description( "The assigned serial number of this software element."): ToSubclass, 
		DisplayName{ "SerialNumber"}, Mappingstrings{ "MIF.DMTF|ComponentID|001.4"}: 
		ToSubclass, Maxlen( 64): ToSubclass, PropertySources{ "SerialNumber"}: ToSubclass, 
		read: ToSubclass]
	STRING SerialNumber;
		[Description( " This is an identifier for this software element and is designed "
				"to be  used in conjunction with other keys to create a unique representation "
				" of this CIM_SoftwareElement"): ToSubclass, DisplayName{ "SoftwareElementID"}, 
		key: DisableOverride  ToInstance  ToSubclass, maxlen( 256): ToSubclass, PropertySources{ 
		"SoftwareElementID"}: ToSubclass, read: ToSubclass]
	STRING SoftwareElementID;
		[Description( " The SoftwareElementState is defined in this model to  identify "
				"various states of a software elements life cycle.   - A software element "
				"in the deployable state describes     the details necessary to successful "
				"distribute it and     the details (conditions and actions) required to create "
				"    a software element in the installable state (i.e., the next state).  "
				"- A software element in the installable state describes     the details necessary "
				"to successfully install it and the    details (conditions and actions required "
				"to create a     software element in the executable state (i.e., the next "
				"state).  - A software element in the executable state describes the     details "
				"necessary to successfully  start it and the details     (conditions and actions "
				"required to create a software element in     the running state (i.e., the "
				"next state).  - A software element in the running state describes the details "
				"    necessary to monitor and operate on a start element."): ToSubclass, DisplayName{ 
		"SoftwareElementState"}, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ 
		"SoftwareElementState"}: ToSubclass, read: ToSubclass, Values{ "Deployable", 
		"Installable", "Executable", "Running"}: ToSubclass]
	UINT16 SoftwareElementState;
		[Description( "The TargetOperatingSystem property allows the provider to specify "
				"the  operating system environment. The value of this property does not  ensure "
				"binary executable.  Two other pieces of information are needed.   First, "
				"the version of the OS needs to be specified using the OS  version check. "
				"The second piece of information is the architecture the  OS runs on. The "
				"combination of these constructs allows the provider to  clearly identify "
				"the level of OS required for a particular software  element."): ToSubclass, 
		DisplayName{ "TargetOperatingSystem"}, key: DisableOverride  ToInstance  ToSubclass, 
		Mappingstrings{ "MIF.DMTF|Software Component Information|002.5"}: ToSubclass, 
		ModelCorrespondence( "CIM_OperatingSystem.OSType"): ToSubclass, PropertySources{ 
		"TargetOperatingSystem"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", 
		"MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", 
		"WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare", 
		"SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000", "ASERIES", 
		"TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive "
				"UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel", 
		"Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE", "NextStep", 
		"PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", "TPF"}: ToSubclass]
	UINT16 TargetOperatingSystem;
		[Description( "Version should be in the form <Major>.<Minor>.<Revision> or <Major>.<Minor><letter><revision>"): 
		ToSubclass, DisplayName{ "Version"}, key: DisableOverride  ToInstance  ToSubclass, 
		Mappingstrings{ "MIF.DMTF|ComponentID|001.3"}: ToSubclass, Maxlen( 64): ToSubclass, 
		PropertySources{ "Version"}: ToSubclass, read: ToSubclass]
	STRING Version;
};
	[Description( "CIM_BIOSElement represents the low-level software that is loaded "
				"into non-volatile storage and used to bring up and configure a computer system."): 
		ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C562-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_BIOSElement"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_BIOSElement:CIM_SoftwareElement
{
		[Description( "Manufacturer of this software element"): ToSubclass, DisplayName{ 
		"Manufacturer"}, Mappingstrings{ "MIF.DMTF|System BIOS|001.2"}: ToSubclass, Maxlen( 
		256): ToSubclass, Override( "Manufacturer"), PropertySources{ "Manufacturer"}: 
		ToSubclass, read: ToSubclass]
	STRING Manufacturer;
		[Description( "If true, this is the primary BIOS of the computer system."): ToSubclass, 
		DisplayName{ "PrimaryBIOS"}, MappingStrings{ "MIF.DMTF|System BIOS|001.9"}: ToSubclass, 
		PropertySources{ "PrimaryBIOS"}: ToSubclass, read: ToSubclass]
	BOOLEAN PrimaryBIOS;
};
	[abstract, Description( "CIM_JobDestination is a logical element representing where "
				"a job is submitted for processing. It can refer to a queue that contains "
				"zero or more jobs, such as a print queue containing print jobs. job destinations "
				"are hosted on systems, similar to the way that services are hosted on systems."): 
		ToSubclass, Locale( 
		1033), UUID( "{673E0A2C-E3D0-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_JobDestination:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The scoping system's creation class name."): ToSubclass, DisplayName{ 
		"SystemCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_System.CreationClassName"): ToSubclass, PropertySources{ 
		"SystemCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The scoping system's name."): ToSubclass, DisplayName{ "SystemName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( 
		"CIM_System.Name"): ToSubclass, PropertySources{ "SystemName"}: ToSubclass, read: 
		ToSubclass]
	STRING SystemName;
};
	[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."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{F126ACC2-E3D4-11d2-8601-0000F8102E5F}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_ServiceAccessPoint"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_ServiceAccessPoint:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The Name property uniquely identifies the service access point "
				"and provides an indication of the functionality that is managed.  This functionality "
				"is described in more detail in the object's Description property."): ToSubclass, 
		DisplayName( "Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Override( "Name"), PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "The scoping system's creation class name."): ToSubclass, DisplayName{ 
		"SystemCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_System.CreationClassName"): ToSubclass, PropertySources{ 
		"SystemCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The scoping system's name."): ToSubclass, DisplayName{ "SystemName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( 
		"CIM_System.Name"): ToSubclass, PropertySources{ "SystemName"}: ToSubclass, read: 
		ToSubclass]
	STRING SystemName;
		[BitValues{ "Write", "Read", "Redirected", "Net_Attached", "unknown"}: ToSubclass, 
		Description( "The Type property indicates the type of SAP such as 'attached' "
				"or 'Redirected'."): ToSubclass, DisplayName{ "Type"}, PropertySources{ "Type"}: 
		ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance  ToSubclass]
	UINT32 Type;
};
	[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."): ToSubclass, DisplayName("Services (CIM)"): ToInstance  ToSubclass, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{8502C527-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_Service"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Service:CIM_LogicalElement
{
		[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."): ToSubclass, DisplayName( "Class Name"): ToInstance 
		 ToSubclass, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "CreationClassName"}: 
		ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[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. "): ToSubclass, 
		DisplayName( "Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, Override( "Name"), PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "Started is a boolean indicating whether the service has been started "
				"(TRUE), or stopped (FALSE)."): ToSubclass, DisplayName( "Started"): ToInstance 
		 ToSubclass, PropertySources{ "Started"}: ToSubclass, read: ToSubclass]
	BOOLEAN Started;
		[Description( "StartMode is a string value indicating whether the Service is automatically "
				"started by a System, Operating System, etc. or only started upon request."): 
		ToSubclass, DisplayName( "Start Mode"): ToInstance  ToSubclass, PropertySources{ 
		"StartMode"}: ToSubclass, read: ToSubclass, ValueMap{ "Automatic", "Manual"}: 
		ToSubclass, Values{ "Automatic", "Manual"}: ToSubclass]
	STRING StartMode;
		[Description( "The scoping System's CreationClassName. "): ToSubclass, DisplayName( 
		"System Class Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance 
		 ToSubclass, Propagated( "CIM_System.CreationClassName"): ToSubclass, PropertySources{ 
		"SystemCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The name of the system that hosts this service"): ToSubclass, DisplayName( 
		"System Name"): ToInstance  ToSubclass, key: DisableOverride  ToInstance  ToSubclass, 
		Propagated( "CIM_System.Name"): ToSubclass, PropertySources{ "SystemName"}: ToSubclass, 
		read: ToSubclass]
	STRING SystemName;
		[Description( "The StartService method places the Service in the started state. "
				"It returns an integer value of 0 if the Service was successfully started, "
				"1 if the request is not supported and any other number to indicate an error. "
				"In a subclass, the set of possible return codes could be specified, using "
				"a ValueMap qualifier on the method. The strings to which the ValueMap contents "
				"are 'translated' may also be specified in the subclass as a Values array "
				"qualifier."): ToSubclass, DisplayName{ "StartService"}, MethodSource{ "StartService"}]
	UINT32 StartService();
		[Description( "The StopService method places the service in the stopped state. "
				"It returns an integer value of 0 if the service was successfully stopped, "
				"1 if the request is not supported and any other number to indicate an error."): 
		ToSubclass, DisplayName{ "StopService"}, MethodSource{ "StopService"}]
	UINT32 StopService();
};
	[abstract, Description( "A file or data set store local to a computer system or "
				"remotely mounted from a file server."): ToSubclass, Locale( 1033), 
				UUID( "{4DA18760-E3D0-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_FileSystem:CIM_LogicalElement
{
		[Description( "AvailableSpace indicates the total amount of free space for the "
				"file system, in bytes. If unknown, enter 0."): ToSubclass, DisplayName{ "AvailableSpace"}, 
		MappingStrings{ "MIF.DMTF|Partition|002.4"}: ToSubclass, PropertySources{ "AvailableSpace"}: 
		ToSubclass, read: ToSubclass, Units( "Bytes"): ToSubclass]
	UINT64 AvailableSpace;
		[Description( "File systems can read/write data in blocks which are defined independently "
				"of the underlying storage extents. This property captures the file system's "
				"block size for data storage and retrieval."): ToSubclass, DisplayName{ "BlockSize"}, 
		PropertySources{ "BlockSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 BlockSize;
		[Description( "Indicates that the case of file names are preserved."): ToSubclass, 
		DisplayName{ "CasePreserved"}, PropertySources{ "CasePreserved"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN CasePreserved;
		[Description( "Indicates that case sensitive file names are supported."): ToSubclass, 
		DisplayName{ "CaseSensitive"}, PropertySources{ "CaseSensitive"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN CaseSensitive;
		[Description( "Array defining the character sets or encoding supported by the "
				"FileSystem. For example, the values, \"ASCII\" (2) or \"ISO2022\" (4), may "
				"be specified."): ToSubclass, DisplayName{ "CodeSet"}, PropertySources{ "CodeSet"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "ASCII", "Unicode", 
		"ISO2022", "ISO8859", "Extended UNIX Code", "UTF-8", "UCS-2"}: ToSubclass]
	UINT16 CodeSet[];
		[Description( "A free form string indicating the algorithm or tool used to compress "
				"the file system. If it is not possible or not desired to describe the compression "
				"scheme (perhaps because it is not known), recommend using the following words: "
				"\"Unknown\" to represent that it is not known whether the file system is "
				"compressed or not, \"Compressed\" to represent that the file system is compressed "
				"but either its compression scheme is not known or not disclosed, and \"Not "
				"Compressed\" to represent that the file system is not compressed."): ToSubclass, 
		DisplayName{ "CompressionMethod"}, MappingStrings{ "MIF.DMTF|Partition|002.7"}: 
		ToSubclass, PropertySources{ "CompressionMethod"}: ToSubclass, read: ToSubclass]
	STRING CompressionMethod;
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The scoping computer system's creation class name."): ToSubclass, 
		DisplayName{ "CSCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, Propagated( "CIM_ComputerSystem.CreationClassName"): 
		ToSubclass, PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The scoping computer system's name."): ToSubclass, DisplayName{ 
		"CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_ComputerSystem.Name"): ToSubclass, PropertySources{ "CSName"}: 
		ToSubclass, read: ToSubclass]
	STRING CSName;
		[Description( "A free form string indicating the algorithm or tool used to encrypt "
				"the file system. If it is not possible or not desired to describe the encryption "
				"scheme (perhaps for security reasons), recommend using the following words: "
				"\"Unknown\" to represent that it is not known whether the file system is "
				"encrypted or not, \"Encrypted\" to represent that the file system is encrypted "
				"but either its encryption scheme is not known or not disclosed, and \"Not "
				"Encrypted\" to represent that the file system is not encrypted."): ToSubclass, 
		DisplayName{ "EncryptionMethod"}, MappingStrings{ "MIF.DMTF|Partition|002.8"}: 
		ToSubclass, PropertySources{ "EncryptionMethod"}: ToSubclass, read: ToSubclass]
	STRING EncryptionMethod;
      [Override ("Name"),DisplayName{"Name"}, key: DisableOverride  ToInstance  ToSubclass, 
	  Description ("The inherited Name serves as key of a FileSystem instance "
	  "within a ComputerSystem."): ToSubclass,
       MaxLen (256): ToSubclass, PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
      
   STRING Name;

		[Description( "The FileSystemSize property stores the total size of the file system "
				"in bytes. If unknown, enter 0."): ToSubclass, DisplayName{ "FileSystemSize"}, 
		PropertySources{ "FileSystemSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 FileSystemSize;
		[Description( "Integer indicating the maximum length of a file name within the "
				"file system. 0 indicates that there is no limit on file name length."): ToSubclass, 
		DisplayName{ "MaxFileNameLength"}, PropertySources{ "MaxFileNameLength"}: ToSubclass, 
		read: ToSubclass]
	UINT32 MaxFileNameLength;
		[Description( "Indicates that the file system is designated as read only."): ToSubclass, 
		DisplayName{ "ReadOnly"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrFSAccess"}: 
		ToSubclass, PropertySources{ "ReadOnly"}: ToSubclass, read: ToSubclass]
	BOOLEAN ReadOnly;
		[Description( "Path name or other information defining the root of the file system."): 
		ToSubclass, DisplayName{ "Root"}, MappingStrings{ "MIB.IETF|HOST-RESOURCES-MIB.hrFSMountPoint"}: 
		ToSubclass, PropertySources{ "Root"}: ToSubclass, read: ToSubclass]
	STRING Root;
};
	[abstract, Description( "A class derived from FileSystem that represents access "
				"of the FileSystem via a network-related service. In this case, the file store "
				"is hosted by a computer, acting as a file server. For example, the file store "
				"for an NFS FileSystem is typically NOT on a ComputerSystem's locally controlled "
				"media, nor is it directly accessed through a device driver. Subclasses of "
				"RemoteFileSystem contain client-side configuration information related to "
				"the access of the FileSystem."): ToSubclass, Locale( 1033), 
				UUID( "{75BCF4F9-DB46-11D2-B4C8-80080C7B6371}"): ToInstance]
class CIM_RemoteFileSystem:CIM_FileSystem
{
};
	[abstract, Description( "A class derived from RemoteFileSystem representing that "
				"the FileSystem is mounted, using the NFS protocol, from a ComputerSystem. "
				"The properties of the NFS object deal with the operational aspects of the "
				"mount and represent the client-side configuration for NFS access. The FileSystemType "
				"(inherited from FileSystem) should be set to indicate the type of this FileSystem "
				"as it appears to the client."): ToSubclass, Locale( 1033), 
				UUID( "{75BCF4FB-DB46-11D2-B4C8-80080C7B6371}"): ToInstance]
class CIM_NFS:CIM_RemoteFileSystem
{
		[Description( "If set to true: control attribute caching is enabled. If set to "
				"false: control attribute caching is disabled."): ToSubclass, DisplayName{ 
		"AttributeCaching"}, PropertySources{ "AttributeCaching"}: ToSubclass, read: 
		ToSubclass]
	BOOLEAN AttributeCaching;
		[Description( "Maximum number of seconds that cached attributes are held after "
				"directory update."): ToSubclass, DisplayName{ "AttributeCachingForDirectoriesMax"}, 
		PropertySources{ "AttributeCachingForDirectoriesMax"}: ToSubclass, read: ToSubclass, 
		Units( "Seconds"): ToSubclass]
	UINT16 AttributeCachingForDirectoriesMax;
		[Description( "Minimum number of seconds that cached attributes are held after "
				"directory update."): ToSubclass, DisplayName{ "AttributeCachingForDirectoriesMin"}, 
		PropertySources{ "AttributeCachingForDirectoriesMin"}: ToSubclass, read: ToSubclass, 
		Units( "Seconds"): ToSubclass]
	UINT16 AttributeCachingForDirectoriesMin;
		[Description( "Maximum number of seconds that cached attributes are held after "
				"file modification."): ToSubclass, DisplayName{ "AttributeCachingForRegularFilesMax"}, 
		PropertySources{ "AttributeCachingForRegularFilesMax"}: ToSubclass, read: ToSubclass, 
		Units( "Seconds"): ToSubclass]
	UINT16 AttributeCachingForRegularFilesMax;
		[Description( "Minimum number of seconds that cached attributes are held after "
				"file modification."): ToSubclass, DisplayName{ "AttributeCachingForRegularFilesMin"}, 
		PropertySources{ "AttributeCachingForRegularFilesMin"}: ToSubclass, read: ToSubclass, 
		Units( "Seconds"): ToSubclass]
	UINT16 AttributeCachingForRegularFilesMin;
		[Description( "If set to true: retries are performed in the foreground. If set "
				"to false: if the first mount attempt fails, retries are performed in the "
				"background."): ToSubclass, DisplayName{ "ForegroundMount"}, PropertySources{ 
		"ForegroundMount"}: ToSubclass, read: ToSubclass]
	BOOLEAN ForegroundMount;
		[Description( "If set to true: once the file system is mounted, NFS requests are "
				"retried until the hosting system responds. If set to false: once the file "
				"system is mounted, an error is returned if the hosting system does not respond."): 
		ToSubclass, DisplayName{ "HardMount"}, PropertySources{ "HardMount"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN HardMount;
		[Description( "If set to true: interrupts are permitted for hard mounts. If set "
				"to false: interrupts are ignored for hard mounts."): ToSubclass, DisplayName{ 
		"Interrupt"}, PropertySources{ "Interrupt"}: ToSubclass, read: ToSubclass]
	BOOLEAN Interrupt;
		[Description( "Maximum number of mount failure retries allowed."): ToSubclass, 
		DisplayName{ "MountFailureRetries"}, PropertySources{ "MountFailureRetries"}: 
		ToSubclass, read: ToSubclass]
	UINT16 MountFailureRetries;
		[Description( "Read buffer size in bytes."): ToSubclass, DisplayName{ "ReadBufferSize"}, 
		PropertySources{ "ReadBufferSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 ReadBufferSize;
		[Description( "Maximum number of NFS retransmissions allowed."): ToSubclass, DisplayName{ 
		"RetransmissionAttempts"}, PropertySources{ "RetransmissionAttempts"}: ToSubclass, 
		read: ToSubclass]
	UINT16 RetransmissionAttempts;
		[Description( "NFS timeout in tenths of a second."): ToSubclass, DisplayName{ 
		"RetransmissionTimeout"}, PropertySources{ "RetransmissionTimeout"}: ToSubclass, 
		read: ToSubclass, Units( "Tenths of Seconds"): ToSubclass]
	UINT32 RetransmissionTimeout;
		[Description( "The remote computer system's (i.e., the NFS File 'Server's) UDP "
				"port number."): ToSubclass, DisplayName{ "ServerCommunicationPort"}, PropertySources{ 
		"ServerCommunicationPort"}: ToSubclass, read: ToSubclass]
	UINT32 ServerCommunicationPort;
		[Description( "Write buffer size in bytes."): ToSubclass, DisplayName{ "WriteBufferSize"}, 
		PropertySources{ "WriteBufferSize"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 WriteBufferSize;
};
	[abstract, Description( "A class derived from FileSystem that represents the file "
				"store controlled by a ComputerSystem through local means (e.g., direct device "
				"driver access). In this case, the file store is managed directly by the ComputerSystem "
				"without the need for another computer to act as a file server. This definition "
				"does not breakdown in the case of a Clustered File System. In this scenario, "
				"the FileSystem is a LocalFileSystem, weak to the Cluster."): ToSubclass, 
		Locale( 1033), UUID( 
		"{5B6C820A-E3D0-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_LocalFileSystem:CIM_FileSystem
{
};
	[Description( "CIM_Job is a logical element representing a unit of work for a system, "
				"such as a print job. A job is distinct from a process in that a job can be "
				"scheduled."): ToSubclass, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{8502C564-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_Job"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Job:CIM_LogicalElement
{
		[Description( "Length of time that the job has been executing."): ToSubclass, 
		DisplayName{ "ElapsedTime"}, PropertySources{ "ElapsedTime"}: ToSubclass, read: 
		ToSubclass]
	DATETIME ElapsedTime;
		[Description( "A free form string representing the job's status."): ToSubclass, 
		DisplayName{ "JobStatus"}, PropertySources{ "JobStatus"}: ToSubclass, read: ToSubclass]
	STRING JobStatus;
		[Description( "User to be notified upon job completion or failure."): ToSubclass, 
		DisplayName{ "Notify"}, PropertySources{ "Notify"}: ToSubclass, read: ToSubclass]
	STRING Notify;
		[Description( "User that submitted the job."): ToSubclass, DisplayName{ "Owner"}, 
		PropertySources{ "Owner"}: ToSubclass, read: ToSubclass]
	STRING Owner;
		[Description( "Priority indicates the urgency or importance of execution of a "
				"job."): ToSubclass, DisplayName{ "Priority"}, PropertySources{ "Priority"}: 
		ToSubclass, read: ToSubclass]
	UINT32 Priority;
		[Description( "Time that the job was begun."): ToSubclass, DisplayName{ "StartTime"}, 
		PropertySources{ "StartTime"}: ToSubclass, read: ToSubclass]
	DATETIME StartTime;
		[Description( "Time that the job was submitted."): ToSubclass, DisplayName{ "TimeSubmitted"}, 
		PropertySources{ "TimeSubmitted"}: ToSubclass, read: ToSubclass]
	DATETIME TimeSubmitted;
		[Description( "Time after which the job is invalid or should be stopped."): ToSubclass, 
		DisplayName{ "UntilTime"}, PropertySources{ "UntilTime"}: ToSubclass, read: ToSubclass]
	DATETIME UntilTime;
};
	[Description( "Threads represent the ability to execute units of a process or task "
				"in parallel.  A process can have many threads, each of which is weak to the "
				"process."): ToSubclass, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{8502C571-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_Thread"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Thread:CIM_LogicalElement
{
		[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 allow all instances of this class and its subclasses "
				"to be uniquely identified."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The scoping computer system's creation class name."): ToSubclass, 
		DisplayName{ "CSCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, Propagated( "CIM_Process.CSCreationClassName"): ToSubclass, 
		PropertySources{ "CSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CSCreationClassName;
		[Description( "The scoping computer system's name."): ToSubclass, DisplayName{ 
		"CSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_Process.CSName"): ToSubclass, PropertySources{ "CSName"}: ToSubclass, 
		read: ToSubclass]
	STRING CSName;
		[Description( "Indicates the current operating condition of the thread. Values "
				"include ready (2), running (3), and blocked (4), among others."): ToSubclass, 
		DisplayName{ "ExecutionState"}, PropertySources{ "ExecutionState"}: ToSubclass, 
		read: ToSubclass, Values{ "Unknown", "Other", "Ready", "Running", "Blocked", 
		"Suspended Blocked", "Suspended Ready"}: ToSubclass]
	UINT16 ExecutionState;
		[Description( "A string used to identify the thread."): ToSubclass, DisplayName{ 
		"Handle"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		PropertySources{ "Handle"}: ToSubclass, read: ToSubclass]
	STRING Handle;
		[Description( "Time in kernel mode, in milliseconds. If this information is not "
				"available, a value of 0 should be used."): ToSubclass, DisplayName{ "KernelModeTime"}, 
		PropertySources{ "KernelModeTime"}: ToSubclass, read: ToSubclass, Units( "MilliSeconds"): 
		ToSubclass]
	UINT64 KernelModeTime;
		[Description( "The scoping operating system's creation class name."): ToSubclass, 
		DisplayName{ "OSCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, Propagated( "CIM_Process.OSCreationClassName"): ToSubclass, 
		PropertySources{ "OSCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING OSCreationClassName;
		[Description( "The scoping operating system's name."): ToSubclass, DisplayName{ 
		"OSName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, 
		Propagated( "CIM_Process.OSName"): ToSubclass, PropertySources{ "OSName"}: ToSubclass, 
		read: ToSubclass]
	STRING OSName;
		[Description( "Priority indicates the urgency or importance of execution of a "
				"thread. A thread may have a different priority than its owning process. If "
				"this information is not available for a thread, a value of 0 should be used."): 
		ToSubclass, DisplayName{ "Priority"}, PropertySources{ "Priority"}: ToSubclass, 
		read: ToSubclass]
	UINT32 Priority;
		[Description( "The scoping process' CreationClassName."): ToSubclass, DisplayName{ 
		"ProcessCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_Process.CreationClassName"): ToSubclass, PropertySources{ 
		"ProcessCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING ProcessCreationClassName;
		[Description( "The scoping process' Handle."): ToSubclass, DisplayName{ "ProcessHandle"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( 
		"CIM_Process.Handle"): ToSubclass, PropertySources{ "ProcessHandle"}: ToSubclass, 
		read: ToSubclass]
	STRING ProcessHandle;
		[Description( "Time in user mode, in milliseconds. If this information is not "
				"available, a value of 0 should be used."): ToSubclass, DisplayName{ "UserModeTime"}, 
		PropertySources{ "UserModeTime"}: ToSubclass, read: ToSubclass, Units( "MilliSeconds"): 
		ToSubclass]
	UINT64 UserModeTime;
};
	[abstract, Description( "Subclasses of CIM_PhysicalElement define any component "
				"of a system that has a distinct physical identity. Instances of this class "
				"can be defined in terms of labels that can be physically attached to the "
				"object. All processes, files, and logical devices are considered not to be "
				"physical elements. For example, it is not possible to attach a label to a "
				"modem. It is only possible to attach a label to the card that implements "
				"the modem. The same card could also implement a LAN  adapter. These are tangible "
				"managed system elements (usually actual hardware items) that have a physical "
				"manifestation of some sort. A managed system element is not necessarily a "
				"discrete component. For example, it is possible for a single card (which "
				"is a type of physical element) to host more than one logical device. The "
				"card would be represented by a single physical element associated with multiple "
				"logical devices."): ToSubclass, Locale( 1033), 
				UUID( "{FAF76B61-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_PhysicalElement:CIM_ManagedSystemElement
{
		[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."): ToSubclass, DisplayName{ "CreationClassName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"CreationClassName"}: ToSubclass, read: ToSubclass]
	STRING CreationClassName;
		[Description( "The name of the organization responsible for producing the physical "
				"element. This may be the entity from whom the element is purchased, but this "
				"is not necessarily true. The latter information is contained in the Vendor "
				"property of CIM_Product."): ToSubclass, DisplayName{ "Manufacturer"}, MaxLen( 
		256): ToSubclass, PropertySources{ "Manufacturer"}: ToSubclass, read: ToSubclass]
	STRING Manufacturer;
		[Description( "The name by which the physical element is generally known."): ToSubclass, 
		DisplayName{ "Model"}, MaxLen( 64): ToSubclass, PropertySources{ "Model"}: ToSubclass, 
		read: ToSubclass]
	STRING Model;
		[Description( "OtherIdentifyingInfo captures additional data, beyond asset tag "
				"information, that could be used to identify a physical element. One example "
				"is bar code data associated with an element that also has an asset tag. Note "
				"that if only bar code data is available and is unique/able to be used as "
				"an element key, this property would be NULL and the bar code data used as "
				"the class key, in the tag property."): ToSubclass, DisplayName{ "OtherIdentifyingInfo"}, 
		PropertySources{ "OtherIdentifyingInfo"}: ToSubclass, read: ToSubclass]
	STRING OtherIdentifyingInfo;
		[Description( "The part number assigned by the organization responsible for producing "
				"or manufacturing the physical element."): ToSubclass, DisplayName{ "PartNumber"}, 
		MaxLen( 256): ToSubclass, PropertySources{ "PartNumber"}: ToSubclass, read: ToSubclass]
	STRING PartNumber;
		[Description( "Boolean indicating that the physical element is powered on (TRUE), "
				"or is currently off (FALSE)."): ToSubclass, DisplayName{ "PoweredOn"}, PropertySources{ 
		"PoweredOn"}: ToSubclass, read: ToSubclass]
	BOOLEAN PoweredOn;
		[Description( "A manufacturer-allocated number used to identify the PhysicalElement."): 
		ToSubclass, DisplayName{ "SerialNumber"}, MaxLen( 64): ToSubclass, PropertySources{ 
		"SerialNumber"}: ToSubclass, read: ToSubclass]
	STRING SerialNumber;
		[Description( "The stock keeping unit number for this physical element."): ToSubclass, 
		DisplayName{ "SKU"}, MaxLen( 64): ToSubclass, PropertySources{ "SKU"}: ToSubclass, 
		read: ToSubclass]
	STRING SKU;
		[Description( "An arbitrary string that uniquely identifies the physicalelement "
				"and serves as the element's key.  The Tag property can contain information "
				"such as asset tag or serial number data. The key for CIM_PhysicalElement "
				"is placed very high in the object hierarchy in order to independently identify "
				"the hardware/entity, regardless of physical placement in or on cabinets, "
				"adapters, etc.  For example, a removable component that can be hot swapped, "
				"may be taken from its containing (scoping) package and be temporarily unused. "
				" The object still continues to exist - and may even be inserted into a different "
				"scoping container.  Therefore, the key for physicalelement is an arbitrary "
				"string and is defined independently of any placement or location-oriented "
				"hierarchy."): ToSubclass, DisplayName{ "Tag"}, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ "Tag"}: ToSubclass, read: 
		ToSubclass]
	STRING Tag;
		[Description( "A string indicating the version of the physical element."): ToSubclass, 
		DisplayName{ "Version"}, MaxLen( 64): ToSubclass, PropertySources{ "Version"}: 
		ToSubclass, read: ToSubclass]
	STRING Version;
};
	[abstract, Description( "The CIM_PhysicalComponent class represents any low-level "
				"or basic component within a package. Any physical element that is not a link, "
				"connector, or package is a descendent (or member) of this class. For example, "
				"the UART chipset on an internal modem card would be a subclass (if additional "
				"properties or associations are defined) or an instance of CIM_PhysicalComponent."): 
		ToSubclass, Locale(1033), UUID( "{FAF76B78-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_PhysicalComponent:CIM_PhysicalElement
{
		[Description( "A physical component can be hot swapped if it is possible to replace "
				"the element with a physically different but equivalent one while the containing "
				"package has power applied to it (i.e., is 'on').  For example, a fan component "
				"may be designed to be hot swapped. All components that can be hot swapped "
				"are inherently removable and replaceable ."): ToSubclass, DisplayName{ "HotSwappable"}, 
		PropertySources{ "HotSwappable"}: ToSubclass, read: ToSubclass]
	BOOLEAN HotSwappable;
		[Description( "A physical component is removable if it is designed to be taken "
				"in and out of the physical container in which it is normally found, without "
				"impairing the function of the overall packaging. A component can still be "
				"removable if power must be 'off' in order to perform the removal. If power "
				"can be 'on' and the component removed, then the element is removable and "
				"can be hot swapped. For example, an upgradeable processor chip is removable."): 
		ToSubclass, DisplayName{ "Removable"}, PropertySources{ "Removable"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN Removable;
		[Description( "A physical component is replaceable  if it is possible to replace "
				"(FRU or upgrade) the element with a physically different one.  For example, "
				"some computer systems allow the main processor chip to be upgraded to one "
				"of a higher clock rating. In this case, the processor is said to be replaceable "
				". All removable components are inherently replaceable ."): ToSubclass, DisplayName{ 
		"Replaceable"}, PropertySources{ "Replaceable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Replaceable;
};
				[Abstract, Description( "The CIM_PhysicalMedia class represents any type of documentation "
				"or storage medium, such as tapes, CD ROMs, etc. This class is typically used "
				"to locate and manage removable media (versus media sealed with the media "
				"access device, as a single package, as is the case with hard disks). However, "
				"'sealed' media can also be modeled using this class, where the media would "
				"then be associated with the physical package using the CIM_PackagedComponent "
				"relationship."): ToSubclass, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
				Union, UUID( "{FAF76B7D-798C-11D2-AAD1-006008C78BC7}"): ToInstance, ViewSources{ 
				"SELECT * FROM CIM_PhysicalMedia"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PhysicalMedia:CIM_PhysicalComponent
{
		[Description( "The number of bytes that can be read from or written to a Media. "
				"This property is not applicable to \"Hard Copy\" (documentation) or cleaner "
				"Media. Data compression should not be assumed, as it would increase the value "
				"in this property. For tapes, it should be assumed that no filemarks or blank "
				"space areas are recorded on the Media."): ToSubclass, DisplayName{ "Capacity"}, 
		PropertySources{ "Capacity"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 Capacity;
		[Description( "Boolean indicating that the physical media is used for cleaning "
				"purposes and not data storage."): ToSubclass, DisplayName{ "CleanerMedia"}, 
		PropertySources{ "CleanerMedia"}: ToSubclass, read: ToSubclass]
	BOOLEAN CleanerMedia;
		[Description( "Additional detail related to the MediaType enumeration. For example, "
				"if value 3 (\"QIC Cartridge\") is specified, this property could indicate "
				"whether the tape is wide or 1/4 inch, whether it is pre-formatted, whether "
				"it is Travan compatible, etc."): ToSubclass, DisplayName{ "MediaDescription"}, 
		ModelCorrespondence{ "CIM_PhysicalMedia.MediaType"}: ToSubclass, PropertySources{ 
		"MediaDescription"}: ToSubclass, read: ToSubclass]
	STRING MediaDescription;
		[Description( "Specifies the type of the physical media, as an enumerated integer. "
				"The MediaDescription property is used to provide more explicit definition "
				"of the media type, whether it is pre-formatted, compatibility features, etc."): 
		ToSubclass, DisplayName{ "MediaType"}, ModelCorrespondence{ "CIM_PhysicalMedia.MediaDescription"}: 
		ToSubclass, PropertySources{ "MediaType"}: ToSubclass, read: ToSubclass, Values{ 
		"Unknown", "Other", "Tape Cartridge", "QIC Cartridge", "AIT Cartridge", "DTF "
				"Cartridge", "DAT Cartridge", "8mm Tape Cartridge", "19mm Tape Cartridge", 
		"DLT Cartridge", "Half-Inch Magnetic Tape Cartridge", "Cartridge Disk", "JAZ "
				"Disk", "ZIP Disk", "SyQuest Disk", "Winchester Removable Disk", "CD-ROM", 
		"CD-ROM/XA", "CD-I", "CD Recordable", "WORM", "Magneto-Optical", "DVD", "DVD+RW", 
		"DVD-RAM", "DVD-ROM", "DVD-Video", "Divx", "Floppy/Diskette", "Hard Disk", "Memory "
				"Card", "Hard Copy", "Clik Disk", "CD-RW", "CD-DA", "CD+", "DVD Recordable", 
		"DVD-RW", "DVD-Audio", "DVD-5", "DVD-9", "DVD-10", "DVD-18", "Magneto-Optical "
				"Rewriteable", "Magneto-Optical Write Once", "Magneto-Optical Rewriteable "
				"(LIMDOW)", "Phase Change Write Once", "Phase Change Rewriteable", "Phase "
				"Change Dual Rewriteable", "Ablative Write Once", "Near Field Recording", 
		"MiniQic", "Travan", "8mm Metal Particle", "8mm Advanced Metal Evaporate", "NCTP", 
		"LTO Ultrium", "LTO Accelis", "9 Track Tape", "18 Track Tape", "36 Track Tape", 
		"Magstar 3590", "Magstar MP", "D2 Tape", "Tape - DST Small ", "Tape - DST Medium", 
		"Tape - DST Large"}: ToSubclass]
	UINT16 MediaType;
		[Description( "Boolean specifying whether the media is currently write protected "
				"by some kind of physical mechanism, such as a protect tab on a floppy diskette."): 
		ToSubclass, DisplayName{ "WriteProtectOn"}, PropertySources{ "WriteProtectOn"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN WriteProtectOn;
};
	[abstract, Description( "The CIM_Chip class represents any type of integrated circuit "
				"hardware, including ASICs, processors, memory chips, etc."): ToSubclass, 
		Locale( 1033), 
		UUID( "{FAF76B7A-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_Chip:CIM_PhysicalComponent
{
		[Description( "The implementation form factor for the chip.For example, values "
				"such as SIMM (7), TSOP (9) or PGA (10) can be specified."): ToSubclass, DisplayName{ 
		"FormFactor"}, PropertySources{ "FormFactor"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "SIP", "DIP", "ZIP", "SOJ", "Proprietary", "SIMM", 
		"DIMM", "TSOP", "PGA", "RIMM", "SODIMM", "SRIMM", "SMD", "SSMP", "QFP", "TQFP", 
		"SOIC", "LCC", "PLCC", "BGA", "FPBGA", "LGA"}: ToSubclass]
	UINT16 FormFactor;
};
	[Description( "CIM_PhysicalMemory is a subclass of CIM_Chip, representing low level "
				"memory devices - SIMMS, DIMMs, raw memory chips, etc."): ToSubclass, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B7B-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_PhysicalMemory"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PhysicalMemory:CIM_Chip
{
		[Description( "A string identifying the physically labeled bank where the memory "
				"is located - for example, 'Bank 0' or 'Bank A'."): ToSubclass, DisplayName{ 
		"BankLabel"}, MappingStrings{ "MIF.DMTF|Memory Device|002.4"}: ToSubclass, MaxLen( 
		64): ToSubclass, PropertySources{ "BankLabel"}: ToSubclass, read: ToSubclass]
	STRING BankLabel;
		[Description( "The total capacity of this physical memory, in bytes."): ToSubclass, 
		DisplayName{ "Capacity"}, MappingStrings{ "MIF.DMTF|Memory Device|002.5"}: ToSubclass, 
		PropertySources{ "Capacity"}: ToSubclass, read: ToSubclass, Units( "Bytes"): 
		ToSubclass]
	UINT64 Capacity;
		[Description( "Data width of the physical memory, in bits. A data width of 0 and "
				"a total width of 8 would indicate that the memory is solely used to provide "
				"error correction bits."): ToSubclass, DisplayName{ "DataWidth"}, MappingStrings{ 
		"MIF.DMTF|Memory Device|002.8"}: ToSubclass, PropertySources{ "DataWidth"}: ToSubclass, 
		read: ToSubclass, Units( "Bits"): ToSubclass]
	UINT16 DataWidth;
		[Description( "The implementation form factor for the chip.For example, values "
				"such as SIMM (7), TSOP (9) or PGA (10) can be specified."): ToSubclass, DisplayName{ 
		"FormFactor"}, MappingStrings{ "MIF.DMTF|Memory Device|002.6"}: ToSubclass, Override( 
		"FormFactor"), PropertySources{ "FormFactor"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "SIP", "DIP", "ZIP", "SOJ", "Proprietary", "SIMM", 
		"DIMM", "TSOP", "PGA", "RIMM", "SODIMM", "SRIMM", "SMD", "SSMP", "QFP", "TQFP", 
		"SOIC", "LCC", "PLCC", "BGA", "FPBGA", "LGA"}: ToSubclass]
	UINT16 FormFactor;
		[Description( "The position of this physical memory in an interleave. 0 indicates "
				"non-interleaved. 1 indicates the first position, 2 the second position and "
				"so on. For example, in a 2:1 interleave, a value of '1' would indicate that "
				"the memory is in the 'even' position."): ToSubclass, DisplayName{ "InterleavePosition"}, 
		MappingStrings{ "MIF.DMTF|Memory Device Mapped Addresses|001.7"}: ToSubclass, 
		PropertySources{ "InterleavePosition"}: ToSubclass, read: ToSubclass]
	UINT32 InterleavePosition;
		[Description( "The type of physical memory."): ToSubclass, DisplayName{ "MemoryType"}, 
		MappingStrings{ "MIF.DMTF|Memory Device|002.9"}: ToSubclass, PropertySources{ 
		"MemoryType"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "DRAM", 
		"Synchronous DRAM", "Cache DRAM", "EDO", "EDRAM", "VRAM", "SRAM", "RAM", "ROM", 
		"Flash", "EEPROM", "FEPROM", "EPROM", "CDRAM", "3DRAM", "SDRAM", "SGRAM", "RDRAM", 
		"DDR"}: ToSubclass]
	UINT16 MemoryType;
		[Description( "Specifies the position of the physical memory in a 'row'. For example, "
				"if it takes two 8-bit memory devices to form a 16-bit row, then a value of "
				"'2'means that this memory is the second device. 0 is an invalid value for "
				"this property."): ToSubclass, DisplayName{ "PositionInRow"}, MappingStrings{ 
		"MIF.DMTF|Memory Device Mapped Addresses|001.6"}: ToSubclass, PropertySources{ 
		"PositionInRow"}: ToSubclass, read: ToSubclass]
	UINT32 PositionInRow;
		[Description( "The speed of the physical memory, in nanoseconds."): ToSubclass, 
		DisplayName{ "Speed"}, PropertySources{ "Speed"}: ToSubclass, read: ToSubclass, 
		Units( "NanoSeconds"): ToSubclass]
	UINT32 Speed;
		[Description( "Total width, in bits, of the physical memory, including check or "
				"error correction bits. If there are no error correction bits, the value in "
				"this property should match that specified for the DataWidth property."): 
		ToSubclass, DisplayName{ "TotalWidth"}, MappingStrings{ "MIF.DMTF|Memory Device|002.7"}: 
		ToSubclass, PropertySources{ "TotalWidth"}: ToSubclass, read: ToSubclass, Units( 
		"Bits"): ToSubclass]
	UINT16 TotalWidth;
};
	[abstract, Description( "The CIM_PhysicalLink class represents the cabling of physical "
				"elements together. For example, serial or Ethernet cables, and infrared Links "
				"would be subclasses (if additional properties or associations are defined) "
				"or instances of CIM_PhysicalLink. In many cases, the numerous physical cables "
				"within a physical package or network will not be modeled. However, where "
				"these cables or links are critical components, or are tagged assets of the "
				"company, these objects can be instantiated using this class or one of its "
				"descendent classes."): ToSubclass, Locale( 1033), UUID( "{FAF76B82-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PhysicalLink:CIM_PhysicalElement
{
		[Description( "The current length of the physical link in feet. For some connections, "
				"especially wireless technologies, this property may not be applicable and "
				"should be left uninitialized."): ToSubclass, DisplayName{ "Length"}, PropertySources{ 
		"Length"}: ToSubclass, read: ToSubclass, Units( "Feet"): ToSubclass]
	REAL64 Length;
		[Description( "The maximum length of the physical link in feet."): ToSubclass, 
		DisplayName{ "MaxLength"}, PropertySources{ "MaxLength"}: ToSubclass, read: ToSubclass, 
		Units( "Feet"): ToSubclass]
	REAL64 MaxLength;
		[Description( "The MediaType property defines the particular type of media through "
				"which transmission signals pass. Common network media include twisted-pair "
				"(value=11 or 12), coaxial (7, 8 or 9) and fiber-optic cable (10)."): ToSubclass, 
		DisplayName{ "MediaType"}, PropertySources{ "MediaType"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "Cat1", "Cat2", "Cat3", "Cat4", "Cat5", "50-ohm Coaxial", 
		"75-ohm Coaxial", "100-ohm Coaxial", "Fiber-optic", "UTP", "STP", "Ribbon Cable", 
		"Twinaxial", "Optical 9um", "Optical 50um", "Optical 62.5um"}: ToSubclass]
	UINT16 MediaType;
		[Description( "Boolean indicating whether the physical link is an actual cable "
				"(TRUE) or a wireless connection (FALSE)."): ToSubclass, DisplayName{ "Wired"}, 
		PropertySources{ "Wired"}: ToSubclass, read: ToSubclass]
	BOOLEAN Wired;
};
	[Description( "The CIM_PhysicalConnector class represents any physical element "
				"that is used to connect to other elements. Any object that can be used to "
				"connect and transmit signals or power between two or more physical elements "
				"is a descendant (or member) of this class. For example, slots and D-shell "
				"connectors are types of physical connectors."): ToSubclass, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B84-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_PhysicalConnector"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_PhysicalConnector:CIM_PhysicalElement
{
		[Description( "A free-form string describing the pin configuration and signal "
				"usage of a physical connector."): ToSubclass, DisplayName{ "ConnectorPinout"}, 
		PropertySources{ "ConnectorPinout"}: ToSubclass, read: ToSubclass]
	STRING ConnectorPinout;
		[Description( "An array of integers defining the type of physical connector. An "
				"array is specified to allow the description of 'combinations' of connector "
				"information. For example, one array entry could specify RS-232 (value=25), "
				"another DB-25 (value=23) and a third entry define the connector as \"Male\" "
				"(value=2)."): ToSubclass, DisplayName{ "ConnectorType"}, PropertySources{ 
		"ConnectorType"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Male", 
		"Female", "Shielded", "Unshielded", "SCSI (A) High-Density (50 pins)", "SCSI "
				"(A) Low-Density (50 pins)", "SCSI (P) High-Density (68 pins)", "SCSI SCA-I "
				"(80 pins)", "SCSI SCA-II (80 pins)", "SCSI Fibre Channel (DB-9, Copper)", 
		"SCSI Fibre Channel (Fibre)", "SCSI Fibre Channel SCA-II (40 pins)", "SCSI Fibre "
				"Channel SCA-II (20 pins)", "SCSI Fibre Channel BNC", "ATA 3-1/2 Inch (40 "
				"pins)", "ATA 2-1/2 Inch (44 pins)", "ATA-2", "ATA-3", "ATA/66", "DB-9", "DB-15", 
		"DB-25", "DB-36", "RS-232C", "RS-422", "RS-423", "RS-485", "RS-449", "V.35", 
		"X.21", "IEEE-488", "AUI", "UTP Category 3", "UTP Category 4", "UTP Category "
				"5", "BNC", "RJ11", "RJ45", "Fiber MIC", "Apple AUI", "Apple GeoPort", "PCI", 
		"ISA", "EISA", "VESA", "PCMCIA", "PCMCIA Type I", "PCMCIA Type II", "PCMCIA Type "
				"III", "ZV Port", "CardBus", "USB", "IEEE 1394", "HIPPI", "HSSDC (6 pins)", 
		"GBIC", "DIN", "Mini-DIN", "Micro-DIN", "PS/2", "Infrared", "HP-HIL", "Access.bus", 
		"NuBus", "Centronics", "Mini-Centronics", "Mini-Centronics Type-14", "Mini-Centronics "
				"Type-20", "Mini-Centronics Type-26", "Bus Mouse", "ADB", "AGP", "VME Bus", 
		"VME64", "Proprietary", "Proprietary Processor Card Slot", "Proprietary Memory "
				"Card Slot", "Proprietary I/O Riser Slot", "PCI-66MHZ", "AGP2X", "AGP4X", 
		"PC-98", "PC-98-Hireso", "PC-H98", "PC-98Note", "PC-98Full", "SSA SCSI", "Circular", 
		"On Board IDE Connector", "On Board Floppy Connector", "9 Pin Dual Inline", "25 "
				"Pin Dual Inline", "50 Pin Dual Inline", "68 Pin Dual Inline", "On Board Sound "
				"Connector", "Mini-jack", "PCI-X", "Sbus IEEE 1396-1993 32 bit", "Sbus IEEE "
				"1396-1993 64 bit", "MCA", "GIO", "XIO", "HIO", "NGIO", "PMC", "MTRJ", "VF-45", 
		"Future I/O", "SC", "SG", "Electrical", "Optical", "Ribbon", "GLM", "1x9", "Mini "
				"SG", "LC", "HSSC", "VHDCI Shielded (68 pins)", "InfiniBand"}: ToSubclass]
	UINT16 ConnectorType[];
};
	[Description( "The Slot class represents Connectors into which Packages are inserted. "
				"For example, a PhysicalPackage that is a DiskDrive may be inserted into an "
				"SCA 'Slot'. As another example, a Card (subclass of PhysicalPackage) may "
				"be inserted into a 16-, 32-, or 64-bit expansion 'Slot' on a HostingBoard. "
				"PCI or PCMCIA Type III Slots are examples of the latter."): ToSubclass, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B86-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Slot"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Slot:CIM_PhysicalConnector
{
		[Description( "An array of integers defining the type of physical connector. An "
				"array is specified to allow the description of 'combinations' of connector "
				"information. For example, one array entry could specify RS-232 (value=25), "
				"another DB-25 (value=23) and a third entry define the connector as \"Male\" "
				"(value=2)."): ToSubclass, DisplayName{ "ConnectorType"}, MappingStrings{ 
		"MIF.DMTF|System Slot|004.2"}: ToSubclass, Override( "ConnectorType"), PropertySources{ 
		"ConnectorType"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Male", 
		"Female", "Shielded", "Unshielded", "SCSI (A) High-Density (50 pins)", "SCSI "
				"(A) Low-Density (50 pins)", "SCSI (P) High-Density (68 pins)", "SCSI SCA-I "
				"(80 pins)", "SCSI SCA-II (80 pins)", "SCSI Fibre Channel (DB-9, Copper)", 
		"SCSI Fibre Channel (Fibre)", "SCSI Fibre Channel SCA-II (40 pins)", "SCSI Fibre "
				"Channel SCA-II (20 pins)", "SCSI Fibre Channel BNC", "ATA 3-1/2 Inch (40 "
				"pins)", "ATA 2-1/2 Inch (44 pins)", "ATA-2", "ATA-3", "ATA/66", "DB-9", "DB-15", 
		"DB-25", "DB-36", "RS-232C", "RS-422", "RS-423", "RS-485", "RS-449", "V.35", 
		"X.21", "IEEE-488", "AUI", "UTP Category 3", "UTP Category 4", "UTP Category "
				"5", "BNC", "RJ11", "RJ45", "Fiber MIC", "Apple AUI", "Apple GeoPort", "PCI", 
		"ISA", "EISA", "VESA", "PCMCIA", "PCMCIA Type I", "PCMCIA Type II", "PCMCIA Type "
				"III", "ZV Port", "CardBus", "USB", "IEEE 1394", "HIPPI", "HSSDC (6 pins)", 
		"GBIC", "DIN", "Mini-DIN", "Micro-DIN", "PS/2", "Infrared", "HP-HIL", "Access.bus", 
		"NuBus", "Centronics", "Mini-Centronics", "Mini-Centronics Type-14", "Mini-Centronics "
				"Type-20", "Mini-Centronics Type-26", "Bus Mouse", "ADB", "AGP", "VME Bus", 
		"VME64", "Proprietary", "Proprietary Processor Card Slot", "Proprietary Memory "
				"Card Slot", "Proprietary I/O Riser Slot", "PCI-66MHZ", "AGP2X", "AGP4X", 
		"PC-98", "PC-98-Hireso", "PC-H98", "PC-98Note", "PC-98Full", "SSA SCSI", "Circular", 
		"On Board IDE Connector", "On Board Floppy Connector", "9 Pin Dual Inline", "25 "
				"Pin Dual Inline", "50 Pin Dual Inline", "68 Pin Dual Inline", "On Board Sound "
				"Connector", "Mini-jack", "PCI-X", "Sbus IEEE 1396-1993 32 bit", "Sbus IEEE "
				"1396-1993 64 bit", "MCA", "GIO", "XIO", "HIO", "NGIO", "PMC", "MTRJ", "VF-45", 
		"Future I/O", "SC", "SG", "Electrical", "Optical", "Ribbon", "GLM", "1x9", "Mini "
				"SG", "LC", "HSSC", "VHDCI Shielded (68 pins)", "InfiniBand"}: ToSubclass]
	UINT16 ConnectorType[];
		[Description( "Maximum height of an adapter card that can be inserted into the "
				"slot, in inches."): ToSubclass, DisplayName{ "HeightAllowed"}, PropertySources{ 
		"HeightAllowed"}: ToSubclass, read: ToSubclass, Units( "Inches"): ToSubclass]
	REAL32 HeightAllowed;
		[Description( "Maximum length of an adapter card that can be inserted into the "
				"slot, in inches."): ToSubclass, DisplayName{ "LengthAllowed"}, PropertySources{ 
		"LengthAllowed"}: ToSubclass, read: ToSubclass, Units( "Inches"): ToSubclass]
	REAL32 LengthAllowed;
		[Description( "Maximum bus width of adapter cards that can be inserted into this "
				"slot, in bits."): ToSubclass, DisplayName{ "MaxDataWidth"}, MappingStrings{ 
		"MIF.DMTF|System Slot|004.3"}: ToSubclass, PropertySources{ "MaxDataWidth"}: 
		ToSubclass, read: ToSubclass, Units( "Bits"): ToSubclass, Values{ "8", "16", 
		"32", "64", "128"}: ToSubclass]
	UINT16 MaxDataWidth;
		[Description( "The Number property indicates the physical slot number, which can "
				"be used as an index into a system slot table, whether or not that slot is "
				"physically occupied."): ToSubclass, DisplayName{ "Number"}, PropertySources{ 
		"Number"}: ToSubclass, read: ToSubclass]
	UINT16 Number;
		[Description( "A free-form string describing that this slot is physically unique "
				"and may hold special types of hardware. This property only has meaning when "
				"the corresponding boolean property, SpecialPurpose, is set to TRUE."): ToSubclass, 
		DisplayName{ "PurposeDescription"}, ModelCorrespondence{ "CIM_Slot.SpecialPurpose"}: 
		ToSubclass, PropertySources{ "PurposeDescription"}: ToSubclass, read: ToSubclass]
	STRING PurposeDescription;
		[Description( "Boolean indicating that this slot is physically unique and may "
				"hold special types of hardware, e.g. a graphics processor slot. If set to "
				"TRUE, then the property, PurposeDescription property (a string), should specify "
				"the nature of the uniqueness or purpose of the slot."): ToSubclass, DisplayName{ 
		"SpecialPurpose"}, ModelCorrespondence{ "CIM_Slot.PurposeDescription"}: ToSubclass, 
		PropertySources{ "SpecialPurpose"}: ToSubclass, read: ToSubclass]
	BOOLEAN SpecialPurpose;
		[Description( "Boolean indicating whether the slot supports hot-plug of adapter "
				"cards."): ToSubclass, DisplayName{ "SupportsHotPlug"}, PropertySources{ "SupportsHotPlug"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN SupportsHotPlug;
		[Description( "Maximum thermal dissipation of the slot in Milliwatts."): ToSubclass, 
		DisplayName{ "ThermalRating"}, MappingStrings{ "MIF.DMTF|System Slot|004.11"}: 
		ToSubclass, PropertySources{ "ThermalRating"}: ToSubclass, read: ToSubclass, 
		Units( "MilliWatts"): ToSubclass]
	UINT32 ThermalRating;
		[Description( "An array of enumerated integers indicating the Vcc voltage supported "
				"by this slot."): ToSubclass, DisplayName{ "VccMixedVoltageSupport"}, MappingStrings{ 
		"MIF.DMTF|System Slot|004.9"}: ToSubclass, PropertySources{ "VccMixedVoltageSupport"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "3.3V", "5V"}: ToSubclass]
	UINT16 VccMixedVoltageSupport[];
		[Description( "An array of enumerated integers indicating the Vpp voltage supported "
				"by this slot."): ToSubclass, DisplayName{ "VppMixedVoltageSupport"}, MappingStrings{ 
		"MIF.DMTF|System Slot|004.10"}: ToSubclass, PropertySources{ "VppMixedVoltageSupport"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "3.3V", "5V", "12V"}: 
		ToSubclass]
	UINT16 VppMixedVoltageSupport[];
};
	[abstract, Description( "The CIM_PhysicalPackage class represents physical elements "
				"that contain or host other components. Examples are a rack enclosure or an "
				"adapter card."): ToSubclass, Locale( 1033), UUID( "{FAF76B6E-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PhysicalPackage:CIM_PhysicalElement
{
		[Description( "The depth of the physical package in inches."): ToSubclass, DisplayName{ 
		"Depth"}, PropertySources{ "Depth"}: ToSubclass, read: ToSubclass, Units( "Inches"): 
		ToSubclass]
	REAL32 Depth;
		[Description( "The height of the physical package in inches."): ToSubclass, DisplayName{ 
		"Height"}, PropertySources{ "Height"}: ToSubclass, read: ToSubclass, Units( "Inches"): 
		ToSubclass]
	REAL32 Height;
		[Description( "A physical package can be hot swapped if it is possible to replace "
				"the element with a physically different but equivalent one while the containing "
				"package has power applied to it (i.e., is 'on').  For example, a disk drive "
				"package inserted using SCA connectors is removable and can be hot swapped. "
				"All packages that can be hot swapped are inherently removable and replaceable."): 
		ToSubclass, DisplayName{ "HotSwappable"}, PropertySources{ "HotSwappable"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN HotSwappable;
		[Description( "A physical package is removable if it is designed to be taken in "
				"and out of the physical container in which it is normally found, without "
				"impairing the function of the overall packaging. A package can still be removable "
				"if power must be 'off' in order to perform the removal. If power can be 'on' "
				"and the package removed, then the element is removable and can be hot swapped. "
				"For example, an extra battery in a laptop is removable, as is a disk drive "
				"package inserted using SCA connectors. However, the latter can be hot swapped. "
				" A laptop's display is not removable, nor is a non-redundant power supply. "
				" Removing these components would impact the function of the overall packaging "
				"or is impossible due to the tight integration of the package."): ToSubclass, 
		DisplayName{ "Removable"}, PropertySources{ "Removable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Removable;
		[Description( "A physical package is replaceable  if it is possible to replace "
				"(FRU or upgrade) the element with a physically different one.  For example, "
				"some computer systems allow the main processor chip to be upgraded to one "
				"of a higher clock rating. In this case, the processor is said to be replaceable "
				". Another example is a power supply package mounted on sliding rails. All "
				"removable packages are inherently replaceable ."): ToSubclass, DisplayName{ 
		"Replaceable"}, PropertySources{ "Replaceable"}: ToSubclass, read: ToSubclass]
	BOOLEAN Replaceable;
		[Description( "The weight of the physical package in pounds."): ToSubclass, DisplayName{ 
		"Weight"}, PropertySources{ "Weight"}: ToSubclass, read: ToSubclass, Units( "Pounds"): 
		ToSubclass]
	REAL32 Weight;
		[Description( "The width of the physical package in inches."): ToSubclass, DisplayName{ 
		"Width"}, PropertySources{ "Width"}: ToSubclass, read: ToSubclass, Units( "Inches"): 
		ToSubclass]
	REAL32 Width;
		[Description( "The IsCompatible method verifies whether the referenced physical "
				"element may be contained by or inserted into the physical package. The return "
				"value should be 0 if the request was successfully executed, 1 if the request "
				"is not supported and some other value if an error occurred.  In a subclass, "
				"the set of possible return codes could be specified, using a ValueMap qualifier "
				"on the method. The strings to which the ValueMap contents are 'translated' "
				"may also be specified in the subclass as a Values array qualifier."): ToSubclass, 
		DisplayName{ "IsCompatible"}, MethodSource{ "IsCompatible"}]
	UINT32 IsCompatible(
	
		[DisplayName{ "ElementToCheck"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"ElementToCheck"}: ToSubclass]
			CIM_PhysicalElement ref ElementToCheck
	);
};
	[abstract, Description( "The CIM_Card class represents a type of physical container "
				"that can be plugged into another card or hosting board, or is itself a hosting "
				"board/motherboard in a chassis. The CIM_Card class includes any package capable "
				"of carrying signals and providing a mounting point for  physical components, "
				"such as chips, or other physical packages, such as other cards."): ToSubclass, 
		Locale( 1033), 
		UUID( "{FAF76B76-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_Card:CIM_PhysicalPackage
{
		[Description( "Boolean indicating that this card is a motherboard or, more generically, "
				"a baseboard in a chassis."): ToSubclass, DisplayName{ "HostingBoard"}, PropertySources{ 
		"HostingBoard"}: ToSubclass, read: ToSubclass]
	BOOLEAN HostingBoard;
		[Description( "A free-form string describing the way(s) in which this card is "
				"physically unique from other cards. This property only has meaning when the "
				"corresponding boolean property, SpecialRequirements, is set to TRUE."): ToSubclass, 
		DisplayName{ "RequirementsDescription"}, ModelCorrespondence{ "CIM_Card.SpecialRequirements"}: 
		ToSubclass, PropertySources{ "RequirementsDescription"}: ToSubclass, read: ToSubclass]
	STRING RequirementsDescription;
		[Description( "Boolean indicating that at least one daughterboard or auxiliary "
				"card is required in order to function properly."): ToSubclass, DisplayName{ 
		"RequiresDaughterBoard"}, PropertySources{ "RequiresDaughterBoard"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN RequiresDaughterBoard;
		[Description( "SlotLayout is a free-form string that describes the slot positioning, "
				"typical usage, restrictions, individual slot spacings or any other pertinent "
				"information for the slots on a card."): ToSubclass, DisplayName{ "SlotLayout"}, 
		PropertySources{ "SlotLayout"}: ToSubclass, read: ToSubclass]
	STRING SlotLayout;
		[Description( "Boolean indicating that this card is physically unique from other "
				"cards of the same type and therefore requires a special slot. For example, "
				"a double-wide card requires two slots. Another example is where a certain "
				"card may be used for the same general function as other cards but requires "
				"a special slot (e.g., extra long), whereas the other cards can be placed "
				"in any available slot. If set to TRUE, then the corresponding property, RequirementsDescription, "
				"should specify the nature of the uniqueness or purpose of the card."): ToSubclass, 
		DisplayName{ "SpecialRequirements"}, ModelCorrespondence{ "CIM_Card.RequirementsDescription"}: 
		ToSubclass, PropertySources{ "SpecialRequirements"}: ToSubclass, read: ToSubclass]
	BOOLEAN SpecialRequirements;
};
	[abstract, Description( "CIM_PhysicalFrame is a superclass of rack, chassis and "
				"other frame enclosures, as they are defined in extension classes. Properties "
				"like visible or audible alarm, and data related to security breaches are "
				"in this superclass."): ToSubclass, Locale( 1033), UUID( "{FAF76B70-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PhysicalFrame:CIM_PhysicalPackage
{
		[Description( "Boolean indicating whether the frame is equipped with an audible "
				"alarm."): ToSubclass, DisplayName{ "AudibleAlarm"}, PropertySources{ "AudibleAlarm"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN AudibleAlarm;
		[Description( "BreachDescription is a free-form string providing more information "
				"if the SecurityBreach property indicates that a breach or some other security-related "
				"event occurred."): ToSubclass, DisplayName{ "BreachDescription"}, ModelCorrespondence{ 
		"CIM_PhysicalFrame.SecurityBreach"}: ToSubclass, PropertySources{ "BreachDescription"}: 
		ToSubclass, read: ToSubclass]
	STRING BreachDescription;
		[Description( "CableManagementStrategy is a free-form string that contains information "
				"on how the various cables are connected and bundled for the frame. With many "
				"networking, storage-related and power cables, cable management can be a complex "
				"and challenging endeavor. This string property contains information to aid "
				"in assembly and service of the frame."): ToSubclass, DisplayName{ "CableManagementStrategy"}, 
		PropertySources{ "CableManagementStrategy"}: ToSubclass, read: ToSubclass]
	STRING CableManagementStrategy;
		[Description( "Boolean indicating whether the frame is protected with a lock."): 
		ToSubclass, DisplayName{ "LockPresent"}, PropertySources{ "LockPresent"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN LockPresent;
		[Description( "SecurityBreach is an enumerated, integer-valued property indicating "
				"whether a physical breach of the frame was attempted but unsuccessful (value=4) "
				"or attempted and successful (5). Also, the values, \"Unknown\", \"Other\" "
				"or \"No Breach\", can be specified."): ToSubclass, DisplayName{ "SecurityBreach"}, 
		MappingStrings{ "MIF.DMTF|Physical Container Global Table|002.12"}: ToSubclass, 
		ModelCorrespondence{ "CIM_PhysicalFrame.BreachDescription"}: ToSubclass, PropertySources{ 
		"SecurityBreach"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5"}: ToSubclass, Values{ "Other", "Unknown", "No Breach", "Breach Attempted", 
		"Breach Successful"}: ToSubclass]
	UINT16 SecurityBreach;
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more detailed explanations for any of the entries in the ServicePhilosophy "
				"array. Note, each entry of this array is related to the entry in ServicePhilosophy "
				"that is located at the same index."): ToSubclass, DisplayName{ "ServiceDescriptions"}, 
		ModelCorrespondence{ "CIM_PhysicalFrame.ServicePhilosophy"}: ToSubclass, PropertySources{ 
		"ServiceDescriptions"}: ToSubclass, read: ToSubclass]
	STRING ServiceDescriptions[];
		[ArrayType( "Indexed"): ToSubclass, Description( "ServicePhilosophy is an enumerated, "
				"integer-valued array that indicates whether the frame is serviced from the "
				"top (value=2), front (3), back (4) or side (5), whether it has sliding trays "
				"(6) or removable sides (7), and/or whether the frame is moveable (8), for "
				"example, having rollers."): ToSubclass, DisplayName{ "ServicePhilosophy"}, 
		ModelCorrespondence{ "CIM_PhysicalFrame.ServiceDescriptions"}: ToSubclass, PropertySources{ 
		"ServicePhilosophy"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Service From Top", "Service From Front", "Service From Back", "Service From "
				"Side", "Sliding Trays", "Removable Sides", "Moveable"}: ToSubclass]
	UINT16 ServicePhilosophy[];
		[Description( "Boolean indicating that the equipment includes a visible alarm."): 
		ToSubclass, DisplayName{ "VisibleAlarm"}, PropertySources{ "VisibleAlarm"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN VisibleAlarm;
};
	[abstract, Description( "A rack is a physical frame that represents an enclosure "
				"in which chassis are placed. Typically a rack is nothing more than the enclosure, "
				"and all the functioning components are packaged in the chassis, loaded in "
				"the rack."): ToSubclass, Locale( 1033), UUID( "{FAF76B71-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_Rack:CIM_PhysicalFrame
{
		[Description( "Designation of the country/region for which the rack is designed. "
				"Country/region code strings are as defined by ISO/IEC 3166. The rack type "
				"is specified in the TypeOfRack property."): ToSubclass, DisplayName{ "CountryDesignation"}, 
		ModelCorrespondence{ "CIM_Rack.TypeOfRack"}: ToSubclass, PropertySources{ "CountryDesignation"}: 
		ToSubclass, read: ToSubclass]
	STRING CountryDesignation;
		[Description( "The height of the physical package in 'U's. A 'U' is a standard "
				"unit of measure for the height of a rack or rack-mountable component. It "
				"is equal to 1.75 inches or 4.445 cm."): ToSubclass, DisplayName{ "Height"}, 
		Override( "Height"), PropertySources{ "Height"}: ToSubclass, read: ToSubclass, 
		Units( "Us"): ToSubclass]
	REAL32 Height;
		[Description( "Enumeration indicating the type of rack.Information such as \"Telco\" "
				"rack (value=2) or standard 19 inch rack (1) can be specified. The country/region "
				"for which the rack is manufactured is defined in the CountryDesignation property."): 
		ToSubclass, DisplayName{ "TypeOfRack"}, ModelCorrespondence{ "CIM_Rack.CountryDesignation"}: 
		ToSubclass, PropertySources{ "TypeOfRack"}: ToSubclass, read: ToSubclass, Values{ 
		"Unknown", "Standard 19 Inch", "Telco", "Equipment Shelf", "Non-Standard"}: ToSubclass]
	UINT16 TypeOfRack;
};
	[Description( "The CIM_Chassis class represents the physical elements that enclose "
				"other elements and provide definable functionality, such as a desktop, processing "
				"node, UPS, disk or tape storage, or a combination of these."): ToSubclass, 
		dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{FAF76B72-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_Chassis"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Chassis:CIM_PhysicalFrame
{
		[ArrayType( "Indexed"): ToSubclass, Description( "An enumerated, integer-valued "
				"array indicating the type of chassis."): ToSubclass, DisplayName{ "ChassisTypes"}, 
		MappingStrings{ "MIF.DMTF|Physical Container Global Table|002.1"}: ToSubclass, 
		ModelCorrespondence{ "CIM_Chassis.TypeDescriptions"}: ToSubclass, PropertySources{ 
		"ChassisTypes"}: ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", 
		"5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", 
		"19", "20", "21", "22", "23", "24"}: ToSubclass, Values{ "Other", "Unknown", 
		"Desktop", "Low Profile Desktop", "Pizza Box", "Mini Tower", "Tower", "Portable", 
		"Laptop", "Notebook", "Hand Held", "Docking Station", "All in One", "Sub Notebook", 
		"Space-Saving", "Lunch Box", "Main System Chassis", "Expansion Chassis", "SubChassis", 
		"Bus Expansion Chassis", "Peripheral Chassis", "Storage Chassis", "Rack Mount "
				"Chassis", "Sealed-Case PC"}: ToSubclass]
	UINT16 ChassisTypes[];
		[Description( "Current required by the chassis at 120V. If power is provided by "
				"the chassis (as in the case of a UPS), this property may indicate the amperage "
				"produced, as a negative number."): ToSubclass, DisplayName{ "CurrentRequiredOrProduced"}, 
		PropertySources{ "CurrentRequiredOrProduced"}: ToSubclass, read: ToSubclass, 
		Units( "Amps at 120 Volts"): ToSubclass]
	SINT16 CurrentRequiredOrProduced;
		[Description( "Amount of heat generated by the chassis in BTU/hour."): ToSubclass, 
		DisplayName{ "HeatGeneration"}, PropertySources{ "HeatGeneration"}: ToSubclass, 
		read: ToSubclass, Units( "BTU per Hour"): ToSubclass]
	UINT16 HeatGeneration;
		[Description( "Integer indicating the number of power cords which must be connected "
				"to the chassis, for all the components to operate."): ToSubclass, DisplayName{ 
		"NumberOfPowerCords"}, PropertySources{ "NumberOfPowerCords"}: ToSubclass, read: 
		ToSubclass]
	UINT16 NumberOfPowerCords;
		[ArrayType( "Indexed"): ToSubclass, Description( "An array of free-form strings "
				"providing more information on the ChassisTypes array entries. Note, each "
				"entry of this array is related to the entry in ChassisTypes that is located "
				"at the same index."): ToSubclass, DisplayName{ "TypeDescriptions"}, ModelCorrespondence{ 
		"CIM_Chassis.ChassisTypes"}: ToSubclass, PropertySources{ "TypeDescriptions"}: 
		ToSubclass, read: ToSubclass]
	STRING TypeDescriptions[];
};
	[Abstract, Description( "Collection is an abstract class that provides a commonsuperclass "
				"for data elements that represent collections of ManagedElements and its subclasses.")]
class CIM_Collection:CIM_ManagedElement
{
};
				[Description( "The CollectionOfMSEs object allows the grouping of ManagedSystemElements "
				"for the purposes of associating Settings and Configurations. It is abstract "
				"to require further definition and semantic refinement in subclasses. The "
				"CollectionOfMSEs object does not carry any state or status information, but "
				"only represents a grouping or 'bag' of Elements. For this reason, it is incorrect "
				"to subclass groups that have state/status from CollectionOfMSEs - an example "
				"is CIM_RedundancyGroup (which is correctly subclassed from LogicalElement)./nCollections "
				"typically aggregate 'like' objects, and represent an optimization. Without "
				"Collections, one is forced to define individual ElementSetting and ElementConfiguration "
				"associations, to tie Settings and Configuration objects to individual ManagedSystemElements. "
				"There may be much duplication in assigning the same Setting to multiple objects. "
				"In addition, using the Collection object allows the determination that the "
				"Setting and Configuration associations are indeed the same for the Collection's "
				"members. This information would otherwise be obtained by defining the Collection "
				"in a proprietary manner, and then querying the ElementSetting and ElementConfiguration "
				"associations to determine if the Collection set is completely covered."): 
				ToSubclass, Abstract, DisplayName{ "CIM_CollectionOfMSEs"}, Locale(1033)]
class CIM_CollectionOfMSEs:CIM_Collection
{
		[Description( "A short textual description (one-line string) of the CollectionOfMSEs "
				"object."): ToSubclass, DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, 
		PropertySources{ "Caption"}: ToSubclass]
	STRING Caption;
		[Description( "The identification of the Collection object. When subclassed, the "
				"CollectionID property can be overridden to be a Key property."): ToSubclass, 
		DisplayName{ "CollectionID"}, MaxLen( 256): ToSubclass, PropertySources{ "CollectionID"}: 
		ToSubclass]
	STRING CollectionID;
		[Description( "A textual description of the CollectionOfMSEs object."): ToSubclass, 
		DisplayName{ "Description"}, PropertySources{ "Description"}: ToSubclass]
	STRING Description;
};
	[abstract, Description( "CIM_StatisticalInformation is a root class for any arbitrary "
				"collection of statistical data and/or metrics applicable to one or more managed "
				"system elements."): ToSubclass, DisplayName{ "CIM_StatisticalInformation"}, 
		Locale( 1033), UUID( "{956597A1-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_StatisticalInformation:CIM_ManagedElement
{
		[Description( "A short textual description (one-line string) for the statistic "
				"or metric."): ToSubclass, DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, 
		PropertySources{ "Caption"}: ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A textual description of the statistic or metric."): ToSubclass, 
		DisplayName{ "Description"}, PropertySources{ "Description"}: ToSubclass, read: 
		ToSubclass]
	STRING Description;
		[Description( "The Name property defines the label by which the statistic or metric "
				"is known. When subclassed, the property can be overridden to be a Key property. "
				""): ToSubclass, DisplayName{ "Name"}, MaxLen( 256): ToSubclass, PropertySources{ 
		"Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
};
	[abstract, Description( "CIM_DeviceErrorCounts is a statistical class containing "
				"error-related counters for a logical device. The types of errors are as defined "
				"by CCITT (Rec X.733) and ISO (IEC 10164-4)."): ToSubclass, DisplayName{ "CIM_DeviceErrorCounts"}, 
		Locale( 1033), UUID( "{117FDB8C-D025-11d2-85F5-0000F8102E5F}"): ToInstance]
class CIM_DeviceErrorCounts:CIM_StatisticalInformation
{
		[Description( "Count of the critical errors. "): ToSubclass, DisplayName{ "CriticalErrorCount"}, 
		MappingStrings{ "MIF.DMTF|Operational State|003.7"}: ToSubclass, PropertySources{ 
		"CriticalErrorCount"}: ToSubclass, read: ToSubclass]
	UINT64 CriticalErrorCount;
		[Description( "The scoping device's creation class name. "): ToSubclass, DisplayName{ 
		"DeviceCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_LogicalDevice.CreationClassName"): ToSubclass, 
		PropertySources{ "DeviceCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING DeviceCreationClassName;
		[Description( "The scoping device's ID. "): ToSubclass, DisplayName{ "DeviceID"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 64): ToSubclass, Propagated( 
		"CIM_LogicalDevice.DeviceID"): ToSubclass, PropertySources{ "DeviceID"}: ToSubclass, 
		read: ToSubclass]
	STRING DeviceID;
		[Description( "Count of the indeterminate errors. "): ToSubclass, DisplayName{ 
		"IndeterminateErrorCount"}, PropertySources{ "IndeterminateErrorCount"}: ToSubclass, 
		read: ToSubclass]
	UINT64 IndeterminateErrorCount;
		[Description( "Count of the major errors. "): ToSubclass, DisplayName{ "MajorErrorCount"}, 
		MappingStrings{ "MIF.DMTF|Operational State|003.8"}: ToSubclass, PropertySources{ 
		"MajorErrorCount"}: ToSubclass, read: ToSubclass]
	UINT64 MajorErrorCount;
		[Description( "Count of the minor errors. "): ToSubclass, DisplayName{ "MinorErrorCount"}, 
		PropertySources{ "MinorErrorCount"}: ToSubclass, read: ToSubclass]
	UINT64 MinorErrorCount;
		[Description( "The inherited Name property serves as part of the key for the CIM_DeviceErrorCounts "
				"instance.  The object is scoped by the logical device to which the statistics "
				"apply. "): ToSubclass, DisplayName{ "Name"}, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Override( "Name"), PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "The scoping system's creation class name. "): ToSubclass, DisplayName{ 
		"SystemCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_LogicalDevice.SystemCreationClassName"): ToSubclass, 
		PropertySources{ "SystemCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The scoping system's name. "): ToSubclass, DisplayName{ "SystemName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( 
		"CIM_LogicalDevice.SystemName"): ToSubclass, PropertySources{ "SystemName"}: 
		ToSubclass, read: ToSubclass]
	STRING SystemName;
		[Description( "Count of the warnings. "): ToSubclass, DisplayName{ "WarningCount"}, 
		MappingStrings{ "MIF.DMTF|Operational State|003.9"}: ToSubclass, PropertySources{ 
		"WarningCount"}: ToSubclass, read: ToSubclass]
	UINT64 WarningCount;
		[Description( "Method to reset the error and warning counters. The method takes "
				"one parameter as input an integer indicating which counter to reset. For "
				"this input parameter, 0 indicates all, 1 indicates a reset of the indeterminate "
				"error counter, 2 the critical error counter, 3 the major error counter, 4 "
				"the minor error counter and 5 the warning counter. The method returns 0 if "
				"successful, 1 if not supported, and any other value if an error occurred. "
				"A method is specified so that the logical device's instrumentation, which "
				"tabulates the errors and warnings, can also reset its internal processing "
				"and counters./nIn a subclass, the set of possible return codes could be specified, "
				"using a ValueMap qualifier on the method. The strings to which the ValueMap "
				"contents are 'translated' may also be specified in the subclass as a Values "
				"array qualifier."): ToSubclass, DisplayName{ "ResetCounter"}, MethodSource{ 
		"ResetCounter"}]
	UINT32 ResetCounter(
	
		[DisplayName{ "SelectedCounter"}, ID( 0): DisableOverride  ToInstance, IN, PropertySources{ 
		"SelectedCounter"}: ToSubclass, Values{ "All", "Indeterminate Error Counter", 
		"Critical Error Counter", "Major Error Counter", "Minor Error Counter", "Warning "
				"Counter"}: ToSubclass]
			UINT16 SelectedCounter
	);
};
	[abstract, Description( "The Setting class represents configuration-related and "
				"operational parameters for one or more ManagedSystemElement(s). A ManagedSystemElement "
				"may have multiple Setting objects associated with it. The current operational "
				"values for an Element's parameters are reflected by properties in the Element "
				"itself or by properties in its associations. These properties do not have "
				"to be the same values present in the Setting object. For example, a modem "
				"may have a Setting baud rate of 56Kb/sec but be operating at 19.2Kb/sec."): 
		ToSubclass, DisplayName{ "CIM_Setting"}, Locale( 1033), UUID( "{8502C572-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_Setting:CIM_ManagedElement
{
		[Description( "A short textual description (one-line string) of the CIM_Setting "
				"object."): ToSubclass, DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, 
		PropertySources{ "Caption"}: ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A textual description of the CIM_Setting object."): ToSubclass, 
		DisplayName{ "Description"}, PropertySources{ "Description"}: ToSubclass, read: 
		ToSubclass]
	STRING Description;
		[Description( "The identifier by which the CIM_Setting object is known."): ToSubclass, 
		DisplayName{ "SettingID"}, MaxLen( 256): ToSubclass, PropertySources{ "SettingID"}: 
		ToSubclass, read: ToSubclass]
	STRING SettingID;
};
	[abstract, Description( "CIM_MonitorResolution describes the relationship between "
				"horizontal and vertical resolutions, refresh rate and scan mode for a desktop "
				"monitor. The actual resolutions, etc. that are in use, are the values specified "
				"in the video controller object."): ToSubclass, DisplayName{ "CIM_MonitorResolution"}, 
		Locale( 1033), UUID( "{1008CCEC-7BFF-11D2-AAD2-006008C78BC7}"): ToInstance]
class CIM_MonitorResolution:CIM_Setting
{
		[Description( "Monitor's horizontal resolution in Pixels."): ToSubclass, DisplayName{ 
		"HorizontalResolution"}, MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.2"}: 
		ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentHorizontalResolution"}: 
		ToSubclass, PropertySources{ "HorizontalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 HorizontalResolution;
		[Description( "Monitor's maximum refresh rate in Hertz, when a range of rates "
				"is supported at the specified resolutions."): ToSubclass, DisplayName{ "MaxRefreshRate"}, 
		MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.7"}: ToSubclass, ModelCorrespondence{ 
		"CIM_VideoController.MaxRefreshRate"}: ToSubclass, PropertySources{ "MaxRefreshRate"}: 
		ToSubclass, read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 MaxRefreshRate;
		[Description( "Monitor's minimum refresh rate in Hertz, when a range of rates "
				"is supported at the specified resolutions."): ToSubclass, DisplayName{ "MinRefreshRate"}, 
		MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.6"}: ToSubclass, ModelCorrespondence{ 
		"CIM_VideoController.MinRefreshRate"}: ToSubclass, PropertySources{ "MinRefreshRate"}: 
		ToSubclass, read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 MinRefreshRate;
		[Description( "Monitor's refresh rate in Hertz. If a range of rates is supported, "
				"use the MinRefreshRate and MaxRefreshRate properties, and set RefreshRate "
				"(this property) to 0."): ToSubclass, DisplayName{ "RefreshRate"}, MappingStrings{ 
		"MIF.DMTF|Monitor Resolutions|002.4"}: ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentRefreshRate"}: 
		ToSubclass, PropertySources{ "RefreshRate"}: ToSubclass, read: ToSubclass, Units( 
		"Hertz"): ToSubclass]
	UINT32 RefreshRate;
		[Description( "Integer indicating whether the monitor operates in interlaced (value=5) "
				"or non-interlaced (4) mode."): ToSubclass, DisplayName{ "ScanMode"}, MappingStrings{ 
		"MIF.DMTF|Monitor Resolutions|002.5"}: ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentScanMode"}: 
		ToSubclass, PropertySources{ "ScanMode"}: ToSubclass, read: ToSubclass, ValueMap{ 
		"1", "2", "3", "4", "5"}: ToSubclass, Values{ "Other", "Unknown", "Not Supported", 
		"Non-Interlaced Operation", "Interlaced Operation"}: ToSubclass]
	UINT16 ScanMode;
		[Description( "The inherited SettingID serves as part of the key for a CIM_MonitorResolution "
				"instance."): ToSubclass, DisplayName{ "SettingID"}, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Override( "SettingID"), PropertySources{ 
		"SettingID"}: ToSubclass, read: ToSubclass]
	STRING SettingID;
		[Description( "Monitor's vertical resolution in Pixels."): ToSubclass, DisplayName{ 
		"VerticalResolution"}, MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.3"}: 
		ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentVerticalResolution"}: 
		ToSubclass, PropertySources{ "VerticalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 VerticalResolution;
};
	[Description( "CIM_VideoControllerResolution describes the various video modes "
				"that a video controller can support.  Video modes are defined by the possible "
				"horizontal and vertical resolutions, refresh rate, scan mode and number of "
				"colors settings supported by a controller. The actual resolutions, etc. that "
				"are in use, are the values specified in the CIM_VideoController object."): 
		ToSubclass, DisplayName{ "CIM_VideoControllerResolution"}, dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{1008CCEA-7BFF-11D2-AAD2-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_VideoControllerResolution"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_VideoControllerResolution:CIM_Setting
{
		[Description( "Controller's horizontal resolution in Pixels."): ToSubclass, DisplayName{ 
		"HorizontalResolution"}, MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.2"}: 
		ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentHorizontalResolution"}: 
		ToSubclass, PropertySources{ "HorizontalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 HorizontalResolution;
		[Description( "Maximum refresh rate in Hertz, when a range of rates is supported "
				"at the specified resolutions."): ToSubclass, DisplayName{ "MaxRefreshRate"}, 
		MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.7"}: ToSubclass, ModelCorrespondence{ 
		"CIM_VideoController.MaxRefreshRate"}: ToSubclass, PropertySources{ "MaxRefreshRate"}: 
		ToSubclass, read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 MaxRefreshRate;
		[Description( "Minimum refresh rate in Hertz, when a range of rates is supported "
				"at the specified resolutions."): ToSubclass, DisplayName{ "MinRefreshRate"}, 
		MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.6"}: ToSubclass, ModelCorrespondence{ 
		"CIM_VideoController.MinRefreshRate"}: ToSubclass, PropertySources{ "MinRefreshRate"}: 
		ToSubclass, read: ToSubclass, Units( "Hertz"): ToSubclass]
	UINT32 MinRefreshRate;
		[Description( "Number of colors supported at the current resolutions."): ToSubclass, 
		DisplayName{ "NumberOfColors"}, ModelCorrespondence{ "CIM_VideoController.CurrentNumberOfColors"}: 
		ToSubclass, PropertySources{ "NumberOfColors"}: ToSubclass, read: ToSubclass]
	UINT64 NumberOfColors;
		[Description( "Refresh rate in Hertz. If a range of rates is supported, use the "
				"MinRefreshRate and MaxRefreshRate properties, and set RefreshRate (this property) "
				"to 0."): ToSubclass, DisplayName{ "RefreshRate"}, MappingStrings{ "MIF.DMTF|Monitor "
				"Resolutions|002.4"}: ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentRefreshRate"}: 
		ToSubclass, PropertySources{ "RefreshRate"}: ToSubclass, read: ToSubclass, Units( 
		"Hertz"): ToSubclass]
	UINT32 RefreshRate;
		[Description( "Integer indicating whether the controller operates in interlaced "
				"(value=5) or non-interlaced (4) mode."): ToSubclass, DisplayName{ "ScanMode"}, 
		MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.5"}: ToSubclass, ModelCorrespondence{ 
		"CIM_VideoController.CurrentScanMode"}: ToSubclass, PropertySources{ "ScanMode"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5"}: ToSubclass, 
		Values{ "Other", "Unknown", "Not Supported", "Non-Interlaced Operation", "Interlaced "
				"Operation"}: ToSubclass]
	UINT16 ScanMode;
		[Description( "The inherited SettingID serves as part of the key for a CIM_VideoControllerResolution "
				"instance."): ToSubclass, DisplayName{ "SettingID"}, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Override( "SettingID"), PropertySources{ 
		"SettingID"}: ToSubclass, read: ToSubclass]
	STRING SettingID;
		[Description( "Controller's vertical resolution in Pixels."): ToSubclass, DisplayName{ 
		"VerticalResolution"}, MappingStrings{ "MIF.DMTF|Monitor Resolutions|002.3"}: 
		ToSubclass, ModelCorrespondence{ "CIM_VideoController.CurrentVerticalResolution"}: 
		ToSubclass, PropertySources{ "VerticalResolution"}: ToSubclass, read: ToSubclass, 
		Units( "Pixels"): ToSubclass]
	UINT32 VerticalResolution;
};
	[abstract, Description( "CIM_StorageError defines blocks of media or memory space "
				"that are mapped 'out of use' due to errors. The Key of the class is the StartingAddress "
				"property of the bytes in error."): ToSubclass, DisplayName{ "CIM_StorageError"}, 
		Locale( 1033), UUID( "{71312AB6-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_StorageError:CIM_ManagedElement
{
		[Description( "The scoping storage extent's creation class name."): ToSubclass, 
		DisplayName{ "DeviceCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, Propagated( "CIM_StorageExtent.CreationClassName"): 
		ToSubclass, PropertySources{ "DeviceCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING DeviceCreationClassName;
		[Description( "The scoping storage extent's DeviceID."): ToSubclass, DisplayName{ 
		"DeviceID"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 64): ToSubclass, 
		Propagated( "CIM_StorageExtent.DeviceID"): ToSubclass, PropertySources{ "DeviceID"}: 
		ToSubclass, read: ToSubclass]
	STRING DeviceID;
		[Description( "The ending address of the bytes in error."): ToSubclass, DisplayName{ 
		"EndingAddress"}, PropertySources{ "EndingAddress"}: ToSubclass, read: ToSubclass]
	UINT64 EndingAddress;
		[Description( "The starting address of the bytes in error."): ToSubclass, DisplayName{ 
		"StartingAddress"}, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ 
		"StartingAddress"}: ToSubclass, read: ToSubclass]
	UINT64 StartingAddress;
		[Description( "The scoping system's creation class name."): ToSubclass, DisplayName{ 
		"SystemCreationClassName"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 
		256): ToSubclass, Propagated( "CIM_StorageExtent.SystemCreationClassName"): ToSubclass, 
		PropertySources{ "SystemCreationClassName"}: ToSubclass, read: ToSubclass]
	STRING SystemCreationClassName;
		[Description( "The scoping system's name."): ToSubclass, DisplayName{ "SystemName"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, Propagated( 
		"CIM_StorageExtent.SystemName"): ToSubclass, PropertySources{ "SystemName"}: 
		ToSubclass, read: ToSubclass]
	STRING SystemName;
};
	[abstract, Description( "CIM_PhysicalCapacity is an abstract class describing a "
				"physical element's minimum/maximum requirements and ability to support different "
				"types of hardware. For example, minimum and maximum memory requirements can "
				"be modeled as a subclass of CIM_PhysicalCapacity."): ToSubclass, DisplayName{ 
		"CIM_PhysicalCapacity"}, Locale( 1033), UUID( "{FAF76B69-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PhysicalCapacity:CIM_ManagedElement
{
		[Description( "Caption is a short textual description (one-line string) of the "
				"CIM_PhysicalCapacity object."): ToSubclass, DisplayName{ "Caption"}, MaxLen( 
		64): ToSubclass, PropertySources{ "Caption"}: ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "The Description property provides a textual description of the "
				"CIM_PhysicalCapacity object."): ToSubclass, DisplayName{ "Description"}, 
		PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "The Name property defines the label by which the CIM_PhysicalCapacity "
				"object is known.  When subclassed, the Name property can be overridden to "
				"be a Key property."): ToSubclass, DisplayName{ "Name"}, MaxLen( 256): ToSubclass, 
		PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
};
	[abstract, Description( "CIM_MemoryCapacity describes the type of memory that can "
				"be installed on a physical element and its minimum/maximum configurations. "
				"Information on what memory is currently 'installed', versus an element's "
				"min/max requirements, is located in instances of the CIM_PhysicalMemory class."): 
		ToSubclass, DisplayName{ "CIM_MemoryCapacity"}, Locale( 1033), UUID( "{FAF76B6B-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_MemoryCapacity:CIM_PhysicalCapacity
{
		[Description( "Maximum amount of memory, in Kbytes, that can be supported by the "
				"associated physical element. "): ToSubclass, DisplayName{ "MaximumMemoryCapacity"}, 
		PropertySources{ "MaximumMemoryCapacity"}: ToSubclass, read: ToSubclass, Units( 
		"KiloBytes"): ToSubclass]
	UINT64 MaximumMemoryCapacity;
		[Description( "The type of memory. This is a part of the object key. Values correspond "
				"to the list of possible memory types in the CIM_PhysicalMemory class."): 
		ToSubclass, DisplayName{ "MemoryType"}, key: DisableOverride  ToInstance  ToSubclass, 
		ModelCorrespondence{ "CIM_PhysicalMemory.MemoryType"}: ToSubclass, PropertySources{ 
		"MemoryType"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "DRAM", 
		"Synchronous DRAM", "Cache DRAM", "EDO", "EDRAM", "VRAM", "SRAM", "RAM", "ROM", 
		"Flash", "EEPROM", "FEPROM", "EPROM", "CDRAM", "3DRAM", "SDRAM", "SGRAM", "RDRAM", 
		"DDR"}: ToSubclass]
	UINT16 MemoryType;
		[Description( "Minimum amount of memory, in Kbytes, that is needed for the associated "
				"physical element to operate correctly. "): ToSubclass, DisplayName{ "MinimumMemoryCapacity"}, 
		PropertySources{ "MinimumMemoryCapacity"}: ToSubclass, read: ToSubclass, Units( 
		"KiloBytes"): ToSubclass]
	UINT64 MinimumMemoryCapacity;
		[Description( "The inherited Name property serves as a part of the CIM_MemoryCapacity "
				"object key."): ToSubclass, DisplayName{ "Name"}, key: DisableOverride  ToInstance 
		 ToSubclass, MaxLen( 256): ToSubclass, Override( "Name"), PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
};
	[abstract, Description( "The CIM_SupportAccess association defines how to obtain "
				"assistance for a Product."): ToSubclass, DisplayName{ "CIM_SupportAccess"}, 
		Locale( 1033), UUID( "{80321714-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_SupportAccess:CIM_ManagedElement
{
		[Description( "CommunicationInfo provides the details of the communication mode. "
				"For example, if the communication mode is 'Phone', CommunicationInfo specifies "
				"the phone number to be called."): ToSubclass, DisplayName{ "CommunicationInfo"}, 
		MappingStrings{ "MIF.DMTF|FRU|002.11", "MIF.DMTF|FRU|002.12"}: ToSubclass, PropertySources{ 
		"CommunicationInfo"}: ToSubclass, read: ToSubclass]
	STRING CommunicationInfo;
		[Description( "communication mode defines the form of communication in order to "
				"obtain support. For example, phone communication (value=2), fax (3) or email "
				"(8) can be specified."): ToSubclass, DisplayName{ "CommunicationMode"}, MappingStrings{ 
		"MIF.DMTF|Support|001.5"}: ToSubclass, PropertySources{ "CommunicationMode"}: 
		ToSubclass, read: ToSubclass, ValueMap{ "1", "2", "3", "4", "5", "6", "7", "8"}: 
		ToSubclass, Values{ "Other", "Phone", "Fax", "BBS", "Online Service", "Web Page", 
		"FTP", "E-mail"}: ToSubclass]
	UINT16 CommunicationMode;
		[Description( "A textual description of the type of support provided."): ToSubclass, 
		DisplayName{ "Description"}, MappingStrings{ "MIF.DMTF|Support|001.3"}: ToSubclass, 
		PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "Locale defines the geographic region and/or language dialect to "
				"which this Support resource pertains."): ToSubclass, DisplayName{ "Locale"}, 
		MappingStrings{ "MIF.DMTF|Support|001.2"}: ToSubclass, MaxLen( 64): ToSubclass, 
		PropertySources{ "Locale"}: ToSubclass, read: ToSubclass]
	STRING Locale;
		[Description( "SupportAccessID is an arbitrary, free form string defined by the "
				"product vendor or by the organization that deploys the product.  This property, "
				"since it is a key, should be unique throughout the enterprise."): ToSubclass, 
		DisplayName{ "SupportAccessId"}, key: DisableOverride  ToInstance  ToSubclass, 
		MaxLen( 256): ToSubclass, PropertySources{ "SupportAccessId"}: ToSubclass, read: 
		ToSubclass]
	STRING SupportAccessId;
};
	[abstract, Description( "The Location class specifies the position and address "
				"of a physical element."): ToSubclass, DisplayName{ "CIM_Location"}, Locale( 
		1033), UUID( "{FAF76B67-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_Location:CIM_ManagedElement
{
		[Description( "Address is a free-form string indicating a street, building or "
				"other type of address for the physical element's location."): ToSubclass, 
		DisplayName{ "Address"}, MaxLen( 1024): ToSubclass, PropertySources{ "Address"}: 
		ToSubclass, read: ToSubclass]
	STRING Address;
		[Description( "Name is a free-form string defining a label for the location. It "
				"is a part of the key for the object."): ToSubclass, DisplayName{ "Name"}, 
		key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "Position is a free-form string indicating the placement of a physical "
				"element.  It can specify slot information on a hosting board, mounting site "
				"in a cabinet, or latitude and longitude information, for example, from a "
				"GPS. It is part of the key of the CIM_Location object."): ToSubclass, DisplayName{ 
		"PhysicalPosition"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): 
		ToSubclass, PropertySources{ "PhysicalPosition"}: ToSubclass, read: ToSubclass]
	STRING PhysicalPosition;
};
	[abstract, Description( "The CIM_FRU class is a vendor-defined collection of products "
				"and/or physical elements that is associated with a product for the purpose "
				"of supporting, maintaining or upgrading that product at the customer's location. "
				"FRU is an acronym for 'field replaceable unit'. "): ToSubclass, DisplayName{ 
		"CIM_FRU"}, Locale( 1033), UUID( "{778C74EE-DB2A-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_FRU:CIM_ManagedElement
{
		[Description( "A short textual description (one-line string) for the FRU."): ToSubclass, 
		DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, PropertySources{ "Caption"}: 
		ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A textual description of the FRU."): ToSubclass, DisplayName{ "Description"}, 
		MappingStrings{ "MIF.DMTF|FRU|002.3"}: ToSubclass, PropertySources{ "Description"}: 
		ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "FRU ordering information."): ToSubclass, DisplayName{ "FRUNumber"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "MIF.DMTF|FRU|002.6"}: 
		ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ "FRUNumber"}: ToSubclass, 
		read: ToSubclass]
	STRING FRUNumber;
		[Description( "FRU identification such as a serial number on software or a die "
				"number on a hardware chip."): ToSubclass, DisplayName{ "IdentifyingNumber"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "MIF.DMTF|FRU|002.7"}: 
		ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ "IdentifyingNumber"}: ToSubclass, 
		read: ToSubclass]
	STRING IdentifyingNumber;
		[Description( "FRU name."): ToSubclass, DisplayName{ "Name"}, MaxLen( 256): ToSubclass, 
		PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( "The FRU's revision level."): ToSubclass, DisplayName{ "RevisionLevel"}, 
		MappingStrings{ "MIF.DMTF|FRU|002.8"}: ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ 
		"RevisionLevel"}: ToSubclass, read: ToSubclass]
	STRING RevisionLevel;
		[Description( "The name of the FRU's supplier."): ToSubclass, DisplayName{ "Vendor"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "MIF.DMTF|FRU|002.4"}: 
		ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ "Vendor"}: ToSubclass, 
		read: ToSubclass]
	STRING Vendor;
};
	[abstract, Description( "A CIM_Action is an operation that is part of a process "
				"to either create a software element in its next state or to eliminate the "
				"software element in the current state. "): ToSubclass, DisplayName{ "CIM_Action"}, 
		Locale( 1033), UUID( "{2F156260-DB21-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_Action:CIM_ManagedElement
{
		[Description( "The ActionID property is a unique identifier assigned to a particular "
				" action for a software element. "): ToSubclass, DisplayName{ "ActionID"}, 
		key: DisableOverride  ToInstance  ToSubclass, maxlen( 256): ToSubclass, PropertySources{ 
		"ActionID"}: ToSubclass, read: ToSubclass]
	STRING ActionID;
		[DisplayName{ "Caption"}, maxlen( 64): ToSubclass, PropertySources{ "Caption"}: 
		ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A description of the object."): ToSubclass, DisplayName{ "Description"}, 
		PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "The Direction property indicates whether a particular   CIM_Action "
				"object is part of a sequence of actions to transition the   current software "
				"element to its next state, such as \"Install\" or to  remove the current "
				"software element, such as \"Uninstall\"."): ToSubclass, DisplayName{ "Direction"}, 
		PropertySources{ "Direction"}: ToSubclass, read: ToSubclass, Values{ "Install", 
		"Uninstall"}: ToSubclass]
	UINT16 Direction;
		[Description( "Name is used to identify this software element"): ToSubclass, DisplayName{ 
		"Name"}, key: DisableOverride  ToInstance  ToSubclass, maxlen( 256): ToSubclass, 
		Propagated( "CIM_SoftwareElement.Name"): ToSubclass, PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( " The SoftwareElementID is an identifier for this software element."): 
		ToSubclass, DisplayName{ "SoftwareElementID"}, key: DisableOverride  ToInstance 
		 ToSubclass, maxlen( 256): ToSubclass, Propagated( "CIM_SoftwareElement.SoftwareElementID"): 
		ToSubclass, PropertySources{ "SoftwareElementID"}: ToSubclass, read: ToSubclass]
	STRING SoftwareElementID;
		[Description( " The SoftwareElementState indicates the state of a software element "
				""): ToSubclass, DisplayName{ "SoftwareElementState"}, key: DisableOverride 
		 ToInstance  ToSubclass, Propagated( "CIM_SoftwareElement.SoftwareElementState"): 
		ToSubclass, PropertySources{ "SoftwareElementState"}: ToSubclass, read: ToSubclass, 
		Values{ "Deployable", "Installable", "Executable", "Running"}: ToSubclass]
	UINT16 SoftwareElementState;
		[Description( "The TargetOperatingSystem indicates the target operating system "
				"of the owning software element."): ToSubclass, DisplayName{ "TargetOperatingSystem"}, 
		key: DisableOverride  ToInstance  ToSubclass, Mappingstrings{ "MIF.DMTF|Software "
				"Component Information|002.5"}: ToSubclass, Propagated( "CIM_SoftwareElement.TargetOperatingSystem"): 
		ToSubclass, PropertySources{ "TargetOperatingSystem"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", 
		"OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", 
		"WIN95", "WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant "
				"UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", 
		"U6000", "ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", 
		"VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", 
		"MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", 
		"HP MPE", "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", 
		"TPF"}: ToSubclass]
	UINT16 TargetOperatingSystem;
		[Description( "Version should be in the form <major>.<minor>.<revision> or <major>.<minor><letter><revision>."): 
		ToSubclass, DisplayName{ "Version"}, key: DisableOverride  ToInstance  ToSubclass, 
		Mappingstrings{ "MIF.DMTF|ComponentID|001.3"}: ToSubclass, Maxlen( 64): ToSubclass, 
		Propagated( "CIM_SoftwareElement.Version"): ToSubclass, PropertySources{ "Version"}: 
		ToSubclass, read: ToSubclass]
	STRING Version;
		[Description( " The invoke method is to take a particular action. The  details "
				"of how the method performs the action is implementation  specific.  The results "
				"of the method are based on the return value.    - A 0 (zero) is returned "
				"if the condition is satisfied.   - A 1 (one) is returned if the method is "
				"not supported.    - Any other value indicates the condition is not satisfied. "
				""): ToSubclass, DisplayName{ "Invoke"}, MethodSource{ "Invoke"}]
	UINT32 Invoke();
};
	[abstract, Description( " The CIM_DirectoryAction is an abstract class that is "
				"used for directories to be managed. Creation of directories is handled by "
				"CIM_CreateDirectoryAction and removal is handled by CIM_RemoveDirectoryAction. "
				""): ToSubclass, DisplayName{ "CIM_DirectoryAction"}, Locale( 1033), UUID( 
		"{8875A39E-DB29-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_DirectoryAction:CIM_Action
{
		[Description( "The DirectoryName indicates the name of the directory to which "
				"the action applies."): ToSubclass, DisplayName{ "DirectoryName"}, maxlen( 
		1024): ToSubclass, PropertySources{ "DirectoryName"}: ToSubclass, read: ToSubclass]
	STRING DirectoryName;
};
	[Description( " The CIM_CreateDirectoryAction creates empty directories for  software "
				"elements to be installed locally."): ToSubclass, DisplayName{ "CIM_CreateDirectoryAction"}, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{87946AAC-DB22-11d2-85FC-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_CreateDirectoryAction"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_CreateDirectoryAction:CIM_DirectoryAction
{
};
	[abstract, Description( " The CIM_RemoveDirectoryAction removes directories for "
				"software elements. "): ToSubclass, DisplayName{ "CIM_RemoveDirectoryAction"}, 
		Locale( 1033), UUID( "{B272D2EA-DB22-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_RemoveDirectoryAction:CIM_DirectoryAction
{
		[Description( "Indicates if the directory must be empty."): ToSubclass, DisplayName{ 
		"MustBeEmpty"}, PropertySources{ "MustBeEmpty"}: ToSubclass, read: ToSubclass]
	BOOLEAN MustBeEmpty;
};
	[abstract, Description( " The CIM_RebootAction causes a reboot of the system where "
				"the software element is installed. "): ToSubclass, DisplayName{ "CIM_RebootAction"}, 
		Locale( 1033), UUID( "{AB08D884-DB30-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_RebootAction:CIM_Action
{
};
	[abstract, Description( "This class specifies the information to be used to modify "
				"a particular setting file for a specific entry with a specific value. The "
				"value specified is created as a new entry or appends to, replaces, removes "
				"from,  or deletes the specified entry. All additions are assumed to be case "
				"sensitive. Removes are assumed to be case insensitive."): ToSubclass, DisplayName{ 
		"CIM_ModifySettingAction"}, Locale( 1033), UUID( "{ECDE0B90-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ModifySettingAction:CIM_Action
{
		[Description( "Type of action to be performed on the specified setting entry. "
				" Create -  Creates the specified entry. Delete - Deletes the specified entry. "
				"Append - Append to the end of the specified entry. Remove - Remove the value "
				"from the specified entry."): ToSubclass, DisplayName{ "ActionType"}, PropertySources{ 
		"ActionType"}: ToSubclass, read: ToSubclass, Values{ "Create", "Delete", "Append", 
		"Remove"}: ToSubclass]
	UINT16 ActionType;
		[Description( "Name of entry to be modified."): ToSubclass, DisplayName{ "EntryName"}, 
		Maxlen( 256): ToSubclass, PropertySources{ "EntryName"}: ToSubclass, read: ToSubclass]
	STRING EntryName;
		[Description( "This is the value to be used to add, append, or replace to the "
				"specified setting."): ToSubclass, DisplayName{ "EntryValue"}, PropertySources{ 
		"EntryValue"}: ToSubclass, read: ToSubclass]
	STRING EntryValue;
		[Description( "File name of setting file entry to be modified."): ToSubclass, 
		DisplayName{ "FileName"}, Maxlen( 1024): ToSubclass, PropertySources{ "FileName"}: 
		ToSubclass, read: ToSubclass]
	STRING FileName;
		[Description( "This is the key of the section of the setting entry to be modified."): 
		ToSubclass, DisplayName{ "SectionKey"}, Maxlen( 256): ToSubclass, PropertySources{ 
		"SectionKey"}: ToSubclass, read: ToSubclass]
	STRING SectionKey;
};
	[abstract, Description( " The CIM_ExecuteProgram causes files to be executed on "
				"the system  where the software element is installed. "): ToSubclass, DisplayName{ 
		"CIM_ExecuteProgram"}, Locale( 1033), UUID( "{149ADDEE-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ExecuteProgram:CIM_Action
{
		[Description( "A string that can be invoked on a system command line."): ToSubclass, 
		DisplayName{ "CommandLine"}, PropertySources{ "CommandLine"}: ToSubclass, read: 
		ToSubclass]
	STRING CommandLine;
		[Description( "The path to the program."): ToSubclass, DisplayName{ "ProgramPath"}, 
		maxlen( 1024): ToSubclass, PropertySources{ "ProgramPath"}: ToSubclass, read: 
		ToSubclass]
	STRING ProgramPath;
};
	[Description( " The CIM_FileAction allows the author to locate files that  already "
				"exist on the users machine, and move or copy those  files to a new location."): 
		ToSubclass, DisplayName{ "CIM_FileAction"}, dynamic: ToInstance, Locale( 1033), 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{2B590C72-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_FileAction"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_FileAction:CIM_Action
{
};
	[Description( "The CIM_RemoveFileAction uninstalls files."): ToSubclass, DisplayName{ 
		"CIM_RemoveFileAction"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		Union, UUID( "{C75D89F8-DB30-11d2-85FC-0000F8102E5F}"): ToInstance, ViewSources{ 
		"SELECT * FROM CIM_RemoveFileAction"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_RemoveFileAction:CIM_FileAction
{
		[Description( "The file name."): ToSubclass, DisplayName{ "File"}, maxlen( 1024): 
		ToSubclass, PropertySources{ "File"}: ToSubclass, read: ToSubclass]
	STRING File;
};
	[Description( " The CIM_CopyFileAction specifies files that  exist on a computer "
				"system, and to move or copy those  files to a new location.   The to/from "
				"information for the copy is specified using  either the CIM_ToDirectorySpecification/CIM_FromDirectorySpecification "
				" or the CIM_ToDirectoryAction/CIM_FromDirectoryAction associations.  The "
				"first set is used when the source and/or the target are to  exist before "
				"any actions are taken. The second set is  used when the source and/or target "
				"are created as a part  of a previous action. In the latter case, the action "
				" to create the directory must occur prior to the CIM_CopyFileAction object. "
				" "): ToSubclass, DisplayName{ "CIM_CopyFileAction"}, dynamic: ToInstance, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{73553260-DB22-11d2-85FC-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_CopyFileAction"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_CopyFileAction:CIM_FileAction
{
		[Description( "Indicates whether to delete the source file after the copy operation."): 
		ToSubclass, DisplayName{ "DeleteAfterCopy"}, PropertySources{ "DeleteAfterCopy"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN DeleteAfterCopy;
		[Description( "The fully qualified destination filename."): ToSubclass, DisplayName{ 
		"Destination"}, maxlen( 1024): ToSubclass, PropertySources{ "Destination"}: ToSubclass, 
		read: ToSubclass]
	STRING Destination;
		[Description( "The fully qualified source filename."): ToSubclass, DisplayName{ 
		"Source"}, maxlen( 1024): ToSubclass, PropertySources{ "Source"}: ToSubclass, 
		read: ToSubclass]
	STRING Source;
};
	[abstract, Description( " A check is a condition or characteristic that is  expected "
				"to be true in an environment defined or  scoped by an instance of a CIM_ComputerSystem. "
				"  The checks associated with a particular software  element are organized "
				"into one of two groups  using the Phase property of the CIM_SoftwareElementChecks "
				" association. Conditions that are expected to be  satisfied when a software "
				"element is in a particular  environment are known as in-state conditions. "
				" Conditions that need to be satisfied in order to  transition the current "
				"software element to its  next state are known as next-state conditions   "
				"A CIM_ComputerSystem object represents the  environment in which CIM_SoftwareElement "
				"are already  installed or in which CIM_SoftwareElement will be installed. "
				" For the case in which a software element is already installed,  the CIM_InstalledSoftwareElement "
				"association is used to  identify the CIM_ComputerSystem object that represents "
				" the \"environment\". When a software elements is being  distributed and "
				"installed on a different computer system, the CIM_ComputerSystem object for "
				"the targeted system  is the environment."): ToSubclass, DisplayName{ "CIM_Check"}, 
		Locale( 1033), UUID( "{7A9135CA-DB21-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_Check:CIM_ManagedElement
{
		[DisplayName{ "Caption"}, Maxlen( 64): ToSubclass, PropertySources{ "Caption"}: 
		ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "An identifier used in conjunction with other keys to uniquely identify "
				"the check"): ToSubclass, DisplayName{ "CheckID"}, key: DisableOverride  ToInstance 
		 ToSubclass, maxlen( 256): ToSubclass, PropertySources{ "CheckID"}: ToSubclass, 
		read: ToSubclass]
	STRING CheckID;
		[Description( " The CheckMode property is used to indicate whether the condition "
				"is  expected to exist or not exist in the environment.  When the value is "
				"True, the condition is expected to exist  (e.g., a file is expected to be "
				"on a system) so invoke() is expected to  return True.  When the value is "
				"False, the condition is not expect to exist  (e.g., a file is not to be on "
				"a system) so invoke is expected to return false "): ToSubclass, DisplayName{ 
		"CheckMode"}, PropertySources{ "CheckMode"}: ToSubclass, read: ToSubclass]
	BOOLEAN CheckMode;
		[Description( " A description of the objects."): ToSubclass, DisplayName{ "Description"}, 
		PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "The name used to identify this software element"): ToSubclass, 
		DisplayName{ "Name"}, key: DisableOverride  ToInstance  ToSubclass, maxlen( 256): 
		ToSubclass, Propagated( "CIM_SoftwareElement.Name"): ToSubclass, PropertySources{ 
		"Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
		[Description( " This is an identifier for this software element."): ToSubclass, 
		DisplayName{ "SoftwareElementID"}, key: DisableOverride  ToInstance  ToSubclass, 
		maxlen( 256): ToSubclass, Propagated( "CIM_SoftwareElement.SoftwareElementID"): 
		ToSubclass, PropertySources{ "SoftwareElementID"}: ToSubclass, read: ToSubclass]
	STRING SoftwareElementID;
		[Description( " The software element state of a software element "): ToSubclass, 
		DisplayName{ "SoftwareElementState"}, key: DisableOverride  ToInstance  ToSubclass, 
		Propagated( "CIM_SoftwareElement.SoftwareElementState"): ToSubclass, PropertySources{ 
		"SoftwareElementState"}: ToSubclass, read: ToSubclass, Values{ "Deployable", 
		"Installable", "Executable", "Running"}: ToSubclass]
	UINT16 SoftwareElementState;
		[Description( " The target operating system of the this software element."): ToSubclass, 
		DisplayName{ "TargetOperatingSystem"}, key: DisableOverride  ToInstance  ToSubclass, 
		Mappingstrings{ "MIF.DMTF|Software Component Information|002.5"}: ToSubclass, 
		Propagated( "CIM_SoftwareElement.TargetOperatingSystem"): ToSubclass, PropertySources{ 
		"TargetOperatingSystem"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", 
		"MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", 
		"WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare", 
		"SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000", "ASERIES", 
		"TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive "
				"UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel", 
		"Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE", "NextStep", 
		"PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", "TPF"}: ToSubclass]
	UINT16 TargetOperatingSystem;
		[Description( "Version should be in the form <Major>.<Minor>.<Revision> or <Major>.<Minor><letter><revision>"): 
		ToSubclass, DisplayName{ "Version"}, key: DisableOverride  ToInstance  ToSubclass, 
		Mappingstrings{ "MIF.DMTF|ComponentID|001.3"}: ToSubclass, Maxlen( 64): ToSubclass, 
		Propagated( "CIM_SoftwareElement.Version"): ToSubclass, PropertySources{ "Version"}: 
		ToSubclass, read: ToSubclass]
	STRING Version;
		[Description( " The invoke method is to evaluate a particular check. The  details "
				"of how the method evaluates a particular check in   a CIM context is described "
				"by the non-abstract CIM_Check sub classes.  The results of the method are "
				"based on the return value.    - A 0 (zero) is returned if the condition is "
				"satisfied.   - A 1 (one) is returned if the method is not supported.    - "
				"Any other value indicates the condition is not satisfied. "): ToSubclass, 
		DisplayName{ "Invoke"}, MethodSource{ "Invoke"}]
	UINT32 Invoke();
};
	[abstract, Description( " The CIM_VersionCompatibilityCheck class specifies whether "
				"it is  permissible to create the next state of a software element. "): ToSubclass, 
		DisplayName{ "CIM_VersionCompatibilityCheck"}, Locale( 1033), UUID( "{D368CA4A-DB31-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_VersionCompatibilityCheck:CIM_Check
{
		[Description( " The AllowDownVersion property indicates that this software element "
				" can transition to its next state even if a higher or latter version  of "
				"the software element already exists in the  environment."): ToSubclass, DisplayName{ 
		"AllowDownVersion"}, PropertySources{ "AllowDownVersion"}: ToSubclass, read: 
		ToSubclass]
	BOOLEAN AllowDownVersion;
		[Description( " The AllowMultipleVersions option controls the ability to configure "
				" multiple versions of a product on a system."): ToSubclass, DisplayName{ 
		"AllowMultipleVersions"}, PropertySources{ "AllowMultipleVersions"}: ToSubclass, 
		read: ToSubclass]
	BOOLEAN AllowMultipleVersions;
		[Description( " The Reinstall property indicates that this software element can "
				" transition to its next state even if a software element of the same  version "
				" already exists in the environment."): ToSubclass, DisplayName{ "Reinstall"}, 
		PropertySources{ "Reinstall"}: ToSubclass, read: ToSubclass]
	BOOLEAN Reinstall;
};
	[Description( " A CIM_FileSpecification identifies a file that is either to  be "
				"on or off the system. The file is to be located in the  directory identified "
				"by the CIM_DirectorySpecificationFile  associations.   When the invoke() "
				"method is used, it is expected that  it will use the combination of information "
				"provided to  check for the file existence. Therefore, any of the  properties "
				"with a NULL value are not checked. So, if  only the Name and the MD5 properties "
				"have values, they  are the only ones consider by the invoke() method.  "): 
		ToSubclass, DisplayName{ "CIM_FileSpecification"}, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( "{41F377B0-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_FileSpecification"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_FileSpecification:CIM_Check
{
		[Description( " The Checksum property is a checksum calculated as the 16-bit  "
				"sum of the first 32 bytes of the file."): ToSubclass, DisplayName{ "CheckSum"}, 
		Mappingstrings{ "MIF.DMTF|Software Signature|002.4"}: ToSubclass, PropertySources{ 
		"CheckSum"}: ToSubclass, read: ToSubclass]
	UINT32 CheckSum;
		[Description( " The CRC1 property is the CRC value calculated using the middle "
				" 512K bytes."): ToSubclass, DisplayName{ "CRC1"}, Mappingstrings{ "MIF.DMTF|Software "
				"Signature|002.5"}: ToSubclass, PropertySources{ "CRC1"}: ToSubclass, read: 
		ToSubclass]
	UINT32 CRC1;
		[Description( " The CRC2 is the CRC value for the middle 512K bytes with a  offset "
				"modulo 3 to the start of the file of zero."): ToSubclass, DisplayName{ "CRC2"}, 
		Mappingstrings{ "MIF.DMTF|Software Signature|002.6"}: ToSubclass, PropertySources{ 
		"CRC2"}: ToSubclass, read: ToSubclass]
	UINT32 CRC2;
		[Description( "The creation date and time of the file. "): ToSubclass, DisplayName{ 
		"CreateTimeStamp"}, PropertySources{ "CreateTimeStamp"}: ToSubclass, read: ToSubclass]
	DATETIME CreateTimeStamp;
		[DisplayName{ "FileSize"}, PropertySources{ "FileSize"}: ToSubclass, read: ToSubclass, 
		units( "KiloBytes"): ToSubclass]
	UINT64 FileSize;
		[Description( " The MD5 algorithm is a well-known algorithm for computing a 128-bit "
				" checksum for any file or object. The likelihood of two different   files "
				"producing the same MD5 checksum is very small  (about 1 in 2^64), and as "
				"such, the MD5 checksum of a file can be  used to construct a reliable content "
				"identifier that is very  likely to uniquely identify the file. The reverse "
				"is also true.  If two files have the same MD5 checksum, it is very likely "
				"that  the files are identical. For purposes of MOF specification  of the "
				"MD5 property, the MD5 algorithm always generates a 32  character string. "
				"For example: The string abcdefghijklmnopqrstuvwxyz  generates the string "
				"c3fcd3d76192e4007dfb496cca67e13b. See http://www. rsa.com/pub/rfc1321.txt "
				"for details on the implementation of the MD5  algorithm."): ToSubclass, DisplayName{ 
		"MD5Checksum"}, maxlen( 16): ToSubclass, PropertySources{ "MD5Checksum"}: ToSubclass, 
		read: ToSubclass]
	STRING MD5Checksum;
};
	[abstract, Description( "CIM_MemoryCheck specifies a condition for the minimum "
				"amount  of memory that needs to be available on a system.  The amount is "
				"specified in the MemorySize property.  The details of this checks are compared "
				"with the  value of the FreePhysicalMemory property of the  CIM_OperatingSystem "
				"object referenced by an CIM_InstalledOS association for the CIM_ComputerSystem "
				"object that describes  the environment.   When the value of FreePhysicalMemory "
				"property is greater  than or equal to the value specified in MemorySize, "
				"the  condition is satisfied. "): ToSubclass, DisplayName{ "CIM_MemoryCheck"}, 
		Locale( 1033), UUID( "{DC0E96FE-DB2A-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_MemoryCheck:CIM_Check
{
		[Description( "The amount of memory that needs to exist on a  computer system "
				"for a software element to executing  properly. "): ToSubclass, DisplayName{ 
		"MemorySize"}, ModelCorrespondence{ "CIM_OperatingSystem.FreePhysicalMemory"}: 
		ToSubclass, PropertySources{ "MemorySize"}: ToSubclass, read: ToSubclass, units( 
		"KiloBytes"): ToSubclass]
	UINT64 MemorySize;
};
	[Description( " The CIM_DirectorySpecification class captures the major directory "
				" structure of a software element.  This class is used to organize  the files "
				"of a software element into manageable units that can  be relocated on a computer "
				"system.  "): ToSubclass, DisplayName{ "CIM_DirectorySpecification"}, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, UUID( 
		"{A524EE6E-DB29-11d2-85FC-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_DirectorySpecification"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DirectorySpecification:CIM_Check
{
		[Description( "The DirectoryPath property is used to capture the name of a directory. "
				" The value supplied by an application provider is actually a default or recommended "
				"path name.  The value can be changed for a particular environment."): ToSubclass, 
		DisplayName{ "DirectoryPath"}, Maxlen( 1024): ToSubclass, PropertySources{ "DirectoryPath"}: 
		ToSubclass, read: ToSubclass]
	STRING DirectoryPath;
		[Description( " The DirectoryType property characterizes the type of directory "
				"being  described. "): ToSubclass, DisplayName{ "DirectoryType"}, Mappingstrings{ 
		"MIF.DMTF|Location|001.2"}: ToSubclass, PropertySources{ "DirectoryType"}: ToSubclass, 
		read: ToSubclass, Values{ "Product base directory", "Product executable directory", 
		"Product library directory", "Product configuration directory", "Product include "
				"directory", "Product working directory", "Product log directory", "Shared "
				"base directory", "Shared executable directory", "Shared library directory", 
		"Shared include directory", "System base directory", "System executable directory", 
		"System library directory", "System configuration directory", "System include "
				"directory", "System log directory", "Other"}: ToSubclass]
	UINT16 DirectoryType;
};
	[abstract, Description( " The CIM_OSVersionCheck class specifies the versions of "
				"the OS that can support this software element. This check can be for a specific, "
				"minimum, maximum or a range of releases of an OS.   To specify a specific "
				"version the minimum and maximum versions must be the same. To specify a minimum, "
				" the minimum version needs only be specified. To specify a maximum  version, "
				"the maximum version needs only be specified. To specify  a range both minimum "
				"and maximum version need to be specified.   The type of operating system "
				"is specified in the TargetOperatingSystem property of the owning software "
				"element.  The details of this checks are compared with the  corresponding "
				"details found in a CIM_OperatingSystem  object referenced by CIM_InstalledOS "
				"association for the  CIM_ComputerSystem object that describes the environment. "
				" As long as there is at least one CIM_OperatingSystem that  satisfies the "
				"details of the condition, the check is  satisfied. In other words, all the "
				"operating systems on  the relevant computer system do not need to satisfy "
				"the  condition. There needs to be at least one.  Also, note the OSType property "
				"of the CIM_OperatingSystem  class must match the type of the TargetOperatingSystem "
				" property. "): ToSubclass, DisplayName{ "CIM_OSVersionCheck"}, Locale( 1033), 
		UUID( "{FEE8368A-DB2A-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_OSVersionCheck:CIM_Check
{
		[Description( " Maximum version of required operating system. The value  is encoded "
				"as     <major>.<minor>.<revision> or     <major>.<minor><letter revision>"): 
		ToSubclass, DisplayName{ "MaximumVersion"}, maxlen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_OperatingSystem.Version"}: ToSubclass, PropertySources{ "MaximumVersion"}: 
		ToSubclass, read: ToSubclass]
	STRING MaximumVersion;
		[Description( " Minimum version of required operating system. The value  is encoded "
				"as     <major>.<minor>.<revision> or     <major>.<minor><letter revision>"): 
		ToSubclass, DisplayName{ "MinimumVersion"}, maxlen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_OperatingSystem.Version"}: ToSubclass, PropertySources{ "MinimumVersion"}: 
		ToSubclass, read: ToSubclass]
	STRING MinimumVersion;
};
	[abstract, Description( " The CIM_SoftwareElementVersionCheck class specifies  "
				"a type of software element that must exist in the environment. This check "
				"can be for a specific,  minimum, maximum or a range of versions. To specify "
				"a specific version the lower and upper versions must be the same. To specify "
				"a minimum the lower version  needs only be specified. To specify a maximum "
				"version the upper version needs only be specified. To specify a range both "
				"upper and lower version need to be specified. The details of this checks "
				"are compared with the corresponding details found in a CIM_SoftwareElement "
				"object referenced by an CIM_InstalledSoftwareElement association for the "
				"CIM_ComputerSystem object. As long as there is at least one CIM_SoftwareElement "
				"that satisfies the details of the condition, the check is satisfied. In other "
				"words, all the software elements on the relevant computer system do not need "
				"to satisfy the condition. There needs to be at least one."): ToSubclass, 
		DisplayName{ "CIM_SoftwareElementVersionCheck"}, Locale( 1033), UUID( "{4D23FBD0-DB31-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_SoftwareElementVersionCheck:CIM_Check
{
		[Description( " The minimum version of a software elements being checked."): ToSubclass, 
		DisplayName{ "LowerSoftwareElementVersion"}, maxlen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_SoftwareElement.Version"}: ToSubclass, PropertySources{ "LowerSoftwareElementVersion"}: 
		ToSubclass, read: ToSubclass]
	STRING LowerSoftwareElementVersion;
		[Description( " The name of the software element being checked. "): ToSubclass, 
		DisplayName{ "SoftwareElementName"}, maxlen( 256): ToSubclass, ModelCorrespondence{ 
		"CIM_SoftwareElement.Name"}: ToSubclass, PropertySources{ "SoftwareElementName"}: 
		ToSubclass, read: ToSubclass]
	STRING SoftwareElementName;
		[Description( " The state of the software element being checked."): ToSubclass, 
		DisplayName{ "SoftwareElementStateDesired"}, maxlen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_SoftwareElement.SoftwareElementState"}: ToSubclass, PropertySources{ "SoftwareElementStateDesired"}: 
		ToSubclass, read: ToSubclass, Values{ "Deployable", "Installable", "Executable", 
		"Running"}: ToSubclass]
	UINT16 SoftwareElementStateDesired;
		[Description( " The target operating system of the software element  being checked."): 
		ToSubclass, DisplayName{ "TargetOperatingSystemDesired"}, maxlen( 64): ToSubclass, 
		ModelCorrespondence{ "CIM_SoftwareElement.TargetOperatingSystem"}: ToSubclass, 
		PropertySources{ "TargetOperatingSystemDesired"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix", 
		"OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", 
		"WIN95", "WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant "
				"UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", 
		"U6000", "ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX", 
		"VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", 
		"MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", 
		"HP MPE", "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated", "VSE", 
		"TPF"}: ToSubclass]
	UINT16 TargetOperatingSystemDesired;
		[Description( " The maximum version of a software elements being checked."): ToSubclass, 
		DisplayName{ "UpperSoftwareElementVersion"}, maxlen( 64): ToSubclass, ModelCorrespondence{ 
		"CIM_SoftwareElement.Version"}: ToSubclass, PropertySources{ "UpperSoftwareElementVersion"}: 
		ToSubclass, read: ToSubclass]
	STRING UpperSoftwareElementVersion;
};
	[abstract, Description( "CIM_DiskSpaceCheck checks the amount of disk space the "
				"needs  to be available on the system. The amount is specified in  the AvailableDiskSpace "
				"property.  The details of this checks are compared with the  value of the "
				"AvailableSpace property of the  CIM_FileSystem object associated with the "
				" CIM_ComputerSystem object that describes the environment.   When the value "
				"of AvailableSpace property is greater  than or equal to the value specified "
				"in  AvailableDiskSpace, the condition is satisfied. "): ToSubclass, DisplayName{ 
		"CIM_DiskSpaceCheck"}, Locale( 1033), UUID( "{D3B1178A-DB29-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_DiskSpaceCheck:CIM_Check
{
		[Description( "The available disk space."): ToSubclass, DisplayName{ "AvailableDiskSpace"}, 
		ModelCorrespondence{ "CIM_FileSystem.AvailableSpace "}: ToSubclass, PropertySources{ 
		"AvailableDiskSpace"}: ToSubclass, read: ToSubclass, units( "KiloBytes"): ToSubclass]
	UINT64 AvailableDiskSpace;
};
	[abstract, Description( " The CIM_SwapSpaceCheck class specifies the amount of "
				"swap space  that needs to be available on the system. The amount is  specified "
				"in the SwapSpaceSize property.  The details of this checks are compared with "
				"the  corresponding details found in a CIM_OperatingSystem  object referenced "
				"by CIM_InstalledOS association for the  CIM_ComputerSystem object describing "
				"the environment.  When the value of TotalSwapSpaceSize property is greater "
				" than or equal to the value specified in  SwapSpacesize, the condition is "
				"satisfied. "): ToSubclass, DisplayName{ "CIM_SwapSpaceCheck"}, Locale( 1033), 
		UUID( "{A5AE701E-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_SwapSpaceCheck:CIM_Check
{
		[Description( " The SwapSpaceSize property specifies the minimum number of Kilobytes "
				" of swap space that needs to be available on the target system."): ToSubclass, 
		DisplayName{ "SwapSpaceSize"}, ModelCorrespondence{ "CIM_OperatingSystem.TotalSwapSpaceSize"}: 
		ToSubclass, PropertySources{ "SwapSpaceSize"}: ToSubclass, read: ToSubclass, 
		units( "KiloBytes"): ToSubclass]
	UINT64 SwapSpaceSize;
};
	[abstract, Description( " This class specifies information needed to check a particular "
				"setting file for a specific entry that contains  a value that is equal to, "
				"or contains, the value specified.  All compares are assumed to be case insensitive."): 
		ToSubclass, DisplayName{ "CIM_SettingCheck"}, Locale( 1033), UUID( "{DC1D8140-DB30-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_SettingCheck:CIM_Check
{
		[Description( "This specifies the way the setting value should be compared."): 
		ToSubclass, DisplayName{ "CheckType"}, PropertySources{ "CheckType"}: ToSubclass, 
		read: ToSubclass, Values{ "Matches", "Contains"}: ToSubclass]
	UINT16 CheckType;
		[Description( "Name of the entry to be checked"): ToSubclass, DisplayName{ "EntryName"}, 
		Maxlen( 256): ToSubclass, PropertySources{ "EntryName"}: ToSubclass, read: ToSubclass]
	STRING EntryName;
		[Description( "Value to be checked that is associated with the named entry."): 
		ToSubclass, DisplayName{ "EntryValue"}, PropertySources{ "EntryValue"}: ToSubclass, 
		read: ToSubclass]
	STRING EntryValue;
		[Description( "File name of the setting file to be checked."): ToSubclass, DisplayName{ 
		"FileName"}, Maxlen( 1024): ToSubclass, PropertySources{ "FileName"}: ToSubclass, 
		read: ToSubclass]
	STRING FileName;
		[Description( "Key of section containing the settings to be checked."): ToSubclass, 
		DisplayName{ "SectionKey"}, Maxlen( 256): ToSubclass, PropertySources{ "SectionKey"}: 
		ToSubclass, read: ToSubclass]
	STRING SectionKey;
};
	[Description( "CIM_Product is a concrete class that is a collection of physical "
				"elements, software features and/or other products, acquired as a unit. Acquisition "
				"implies an agreement between supplier and consumer which may have implications "
				"to product licensing, support and warranty."): ToSubclass, DisplayName{ "CIM_Product"}, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), Union, 
		UUID( "{FAF76B63-798C-11D2-AAD1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_Product"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Product:CIM_ManagedElement
{
		[Description( "A short textual description (one-line string) for the Product."): 
		ToSubclass, DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, PropertySources{ 
		"Caption"}: ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A textual description of the product."): ToSubclass, DisplayName{ 
		"Description"}, PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "Product identification such as a serial number on software, a die "
				"number on a hardware chip, or (for non-commercial Products) a project number."): 
		ToSubclass, DisplayName{ "IdentifyingNumber"}, key: DisableOverride  ToInstance 
		 ToSubclass, MappingStrings{ "MIF.DMTF|ComponentID|001.4"}: ToSubclass, MaxLen( 
		64): ToSubclass, PropertySources{ "IdentifyingNumber"}: ToSubclass, read: ToSubclass]
	STRING IdentifyingNumber;
		[Description( "Commonly used product name."): ToSubclass, DisplayName{ "Name"}, 
		key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ "MIF.DMTF|ComponentID|001.2"}: 
		ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ "Name"}: ToSubclass, read: 
		ToSubclass]
	STRING Name;
		[Description( "Product SKU (stock keeping unit) information."): ToSubclass, DisplayName{ 
		"SKUNumber"}, MaxLen( 64): ToSubclass, PropertySources{ "SKUNumber"}: ToSubclass, 
		read: ToSubclass]
	STRING SKUNumber;
		[Description( "The name of the Product's supplier, or entity selling the Product "
				"(the manufacturer, reseller, OEM, etc.). Corresponds to the Vendor property "
				"in the Product object in the DMTF Solution Exchange Standard."): ToSubclass, 
		DisplayName{ "Vendor"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"MIF.DMTF|ComponentID|001.1"}: ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ 
		"Vendor"}: ToSubclass, read: ToSubclass]
	STRING Vendor;
		[Description( "Product version information.  Corresponds to the Version property "
				"in the product object in the DMTF Solution Exchange Standard."): ToSubclass, 
		DisplayName{ "Version"}, key: DisableOverride  ToInstance  ToSubclass, MappingStrings{ 
		"MIF.DMTF|ComponentID|001.3"}: ToSubclass, MaxLen( 64): ToSubclass, PropertySources{ 
		"Version"}: ToSubclass, read: ToSubclass]
	STRING Version;
};
	[abstract, Description( "The CIM_ReplacementSet class aggregates physical elements "
				"that must be 'replaced' or 'FRUed' together. For example, when replacing "
				"a memory card, the component memory chips could be removed and replaced as "
				"well. Or, a set of memory chips may be specified to be replaced or upgraded "
				"together using this association."): ToSubclass, DisplayName{ "CIM_ReplacementSet"}, 
		Locale( 1033), UUID( "{FAF76B6C-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ReplacementSet:CIM_ManagedElement
{
		[Description( "A free-form string specifying information related to the CIM_ReplacementSet. "
				" The purpose of the set or information related to how the component elements "
				"are replaced may be included in this property."): ToSubclass, DisplayName{ 
		"Description"}, PropertySources{ "Description"}: ToSubclass, read: ToSubclass]
	STRING Description;
		[Description( "Name is a free-form string defining a label for the CIM_ReplacementSet. "
				"It is the key for the object."): ToSubclass, DisplayName{ "Name"}, key: DisableOverride 
		 ToInstance  ToSubclass, MaxLen( 256): ToSubclass, PropertySources{ "Name"}: 
		ToSubclass, read: ToSubclass]
	STRING Name;
};
	[abstract, Description( "The Configuration object allows the grouping of sets of "
				"parameters (defined in CIM_Setting objects) and dependencies for one or more "
				"managed system elements. The Configuration object represents a certain behavior, "
				"or a desired functional state for the managed system elements. The desired "
				"functional state is typically driven by external requirements such as time "
				"or location. For example, to connect to a mail system from 'home', a dependency "
				"on a modem exists, but a dependency on a network adapter exists at 'work'. "
				"Settings for the pertinent logical devices (in this example, POTS modem and "
				"network adapter) can be defined and aggregated by CIM_Configuration. Therefore, "
				"two 'Connect to Mail' configurations may be defined grouping the relevant "
				"dependencies and CIM_Setting objects."): ToSubclass, DisplayName{ "CIM_Configuration"}, 
		Locale( 1033), UUID( "{4C51D7AE-DB22-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_Configuration:CIM_ManagedElement
{
		[Description( "A short textual description (one-line string) of the CIM_Configuration "
				"object."): ToSubclass, DisplayName{ "Caption"}, MaxLen( 64): ToSubclass, 
		PropertySources{ "Caption"}: ToSubclass, read: ToSubclass]
	STRING Caption;
		[Description( "A textual description of the CIM_Configuration object."): ToSubclass, 
		DisplayName{ "Description"}, PropertySources{ "Description"}: ToSubclass, read: 
		ToSubclass]
	STRING Description;
		[Description( "The label by which the CIM_Configuration object is known."): ToSubclass, 
		DisplayName{ "Name"}, key: DisableOverride  ToInstance  ToSubclass, MaxLen( 256): 
		ToSubclass, PropertySources{ "Name"}: ToSubclass, read: ToSubclass]
	STRING Name;
};
	[Aggregation, Association, Description( "CIM_MemberOfCollection is an aggregation "
				"used to establish membership of ManagedElements in a Collection.")]
class CIM_MemberOfCollection
{
		[Aggregate, Description( "The Collection that aggregates members"), key: DisableOverride 
		 ToInstance  ToSubclass]
	CIM_Collection ref Collection;
		[Description( "The aggregated member of the collection."), key: DisableOverride 
		 ToInstance  ToSubclass]
	CIM_ManagedElement ref Member;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"generic association to establish dependency relationships between objects."): 
		ToSubclass, DisplayName{ "CIM_Dependency"}, Locale( 1033), UUID( "{8502C53A-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_Dependency
{
		[Key: ToSubclass, Description( "Antecedent represents the independent object in this association."): 
		ToSubclass, DisplayName{ "Antecedent"}, PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_ManagedElement ref Antecedent;
		[Key: ToSubclass, Description( "Dependent represents the object dependent on the Antecedent."): 
		ToSubclass, DisplayName{ "Dependent"}, PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_ManagedElement ref Dependent;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( "An association "
				"between logical devices and system resources, indicating that the resource "
				"is assigned to the device."): ToSubclass, DisplayName{ "CIM_AllocatedResource"}, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), UUID( 
		"{8502C579-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_AllocatedResource"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_AllocatedResource:CIM_Dependency
{
		[Description( "The resource."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_SystemResource ref Antecedent;
		[Description( "The logical device to which the resource is assigned."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"link between BIOS element and non-volatile storage where the BIOS is loaded."): 
		ToSubclass, DisplayName{ "CIM_BIOSLoadedInNV"}, Locale( 1033), UUID( "{524ED194-DB35-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_BIOSLoadedInNV:CIM_Dependency
{
		[Description( "The non-volatile storage."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_NonVolatileStorage ref Antecedent;
		[Description( "The BIOS stored in the non-volatile extent."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_BIOSElement ref Dependent;
		[Description( "The ending address where the BIOS is located in non-volatile storage."): 
		ToSubclass, DisplayName{ "EndingAddress"}, PropertySources{ "EndingAddress"}: 
		ToSubclass, read: ToSubclass]
	UINT64 EndingAddress;
		[Description( "The starting address where the BIOS is located in non-volatile "
				"storage."): ToSubclass, DisplayName{ "StartingAddress"}, PropertySources{ 
		"StartingAddress"}: ToSubclass, read: ToSubclass]
	UINT64 StartingAddress;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Specifies "
				"the logical device that is associated with, and accessed using the referenced "
				"CIM_DeviceFile."): ToSubclass, DisplayName{ "CIM_DeviceAccessedByFile"}, 
		Locale( 1033), UUID( "{05D1FFF2-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_DeviceAccessedByFile:CIM_Dependency
{
		[Description( "The device file."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_DeviceFile ref Antecedent;
		[Description( "The device that is accessed using the device file."): ToSubclass, 
		DisplayName{ "Dependent"}, Max( 1): ToSubclass, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ElementsLinked association indicates which physical elements are cabled "
				"together by a physical link."): ToSubclass, DisplayName{ "CIM_ElementsLinked"}, 
		Locale( 1033), UUID( "{FAF76B83-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ElementsLinked:CIM_Dependency
{
		[Description( "The physical link."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalLink ref Antecedent;
		[Description( "The physical element that is linked."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_PhysicalElement ref Dependent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Often, a temperature sensor is installed in a package such as a "
				"chassis or a rack, not to measure any particular device, but the package's "
				"environment in general.  This relationship is described by the CIM_PackageTempSensor "
				"association."): ToSubclass, DisplayName{ "CIM_PackageTempSensor"}, Locale( 
		1033), UUID( "{FAF76B8F-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_PackageTempSensor:CIM_Dependency
{
		[Description( "The temperature sensor for the package."): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_TemperatureSensor ref Antecedent;
		[Description( "The physical package whose environment is monitored."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Logical "
				"devices may have memory installed on them or otherwise associated with them "
				"- such as cache memory. This is made explicit in this association."): ToSubclass, 
		DisplayName{ "CIM_AssociatedMemory"}, Locale( 1033), UUID( "{464FFAB0-946F-11d2-AAE2-006008C78BC7}"): 
		ToInstance]
class CIM_AssociatedMemory:CIM_Dependency
{
		[Description( "Memory installed on or associated with a device."): ToSubclass, 
		DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Memory ref Antecedent;
		[Description( "The logical device."): ToSubclass, DisplayName{ "Dependent"}, Override( 
		"Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[Association: ToInstance  ToSubclass, Description( "Associates "
				"the processor and system memory, or a processor's cache."): ToSubclass, DisplayName{ 
		"CIM_AssociatedProcessorMemory"}, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), UUID( "{464FFAB1-946F-11d2-AAE2-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_AssociatedProcessorMemory"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_AssociatedProcessorMemory:CIM_AssociatedMemory
{
		[Description( "Speed of the bus, in MHertz, between the processor and memory. "
				""): ToSubclass, DisplayName{ "BusSpeed"}, PropertySources{ "BusSpeed"}: ToSubclass, 
		read: ToSubclass, Units( "MegaHertz"): ToSubclass]
	UINT32 BusSpeed;
		[Description( "The processor that accesses the memory or uses the cache."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Processor ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"laptop, a type of chassis, may be docked in another type of chassis, a docking "
				"station. This is the relationship represented by the CIM_Docked association. "
				"Because this is such a typical relationship, it is explicitly described."): 
		ToSubclass, DisplayName{ "CIM_Docked"}, Locale( 1033), MappingStrings{ "MIF.DMTF|Dynamic "
				"States|001.2"}: ToSubclass, UUID( "{FAF76B75-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_Docked:CIM_Dependency
{
		[Description( "The docking station."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Chassis ref Antecedent;
		[Description( "The laptop that is 'docked'."): ToSubclass, DisplayName{ "Dependent"}, 
		Max( 1): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Chassis ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Often, "
				"a cooling device is installed in a package such as a chassis or a rack, not "
				"for a specific device, but to assist in the cooling of the package in general. "
				" This relationship is described by the CIM_PackageCooling association."): 
		ToSubclass, DisplayName{ "CIM_PackageCooling"}, Locale( 1033), UUID( "{FAF76B8E-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PackageCooling:CIM_Dependency
{
		[Description( "The cooling device for the package."): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_CoolingDevice ref Antecedent;
		[Description( "The physical package whose environment is cooled."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"link between the operating system and the file system(s) from which this "
				"operating system is loaded. The association is many-to-many since a distributed "
				"OS could depend on several file systems in order to correctly and completely "
				"load."): ToSubclass, DisplayName{ "CIM_BootOSFromFS"}, Locale( 1033), UUID( 
		"{5F5B101E-DB35-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_BootOSFromFS:CIM_Dependency
{
		[Description( "The file system from which the operating system is loaded."): ToSubclass, 
		DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_FileSystem ref Antecedent;
		[Description( "The operating system."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_OperatingSystem ref Dependent;
};
	[Abstract, Association: ToInstance  ToSubclass, 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 service accesspoints, "
				"potentially hosted on different systems."): ToSubclass, DisplayName{ "CIM_ServiceAccessBySAP"}, 
		dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), UUID( 
		"{714C00BA-DB37-11d2-85FC-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT * "
				"FROM CIM_ServiceAccessBySAP"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_ServiceAccessBySAP:CIM_Dependency
{
		[Description( "The service. "): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Service ref Antecedent;
		[Description( "An access point for a service. Access points are dependent in this "
				"relationship since they have no function without a corresponding service. "
				""): ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_ServiceAccessPoint ref Dependent;
};
	[Association: ToInstance  ToSubclass, Description( "A logical "
				"device may use or require one or more batteries. This relationship is described "
				"by the CIM_AssociatedBattery dependency. It is also possible to model the "
				"individual batteries that comprise a UPS, using this association."): ToSubclass, 
		DisplayName{ "CIM_AssociatedBattery"}, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), UUID( "{8502C578-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_AssociatedBattery"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_AssociatedBattery:CIM_Dependency
{
		[Description( "The battery."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Battery ref Antecedent;
		[Description( "The logical device needing or associated with the battery"): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_SAPSAPDependency "
				"is an association between a service access point and another service access "
				"point indicating that the latter is required in order for the former service "
				"access point to utilize or connect with its service. For example, to print "
				"at a network printer, local print access points must utilize underlying network-related "
				"SAPs, or protocol endpoints, in order to send the print request."): ToSubclass, 
		DisplayName{ "CIM_SAPSAPDependency"}, Locale( 1033), UUID( "{422D175A-E3D5-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_SAPSAPDependency:CIM_Dependency
{
		[Description( "The required service access point."): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_ServiceAccessPoint ref Antecedent;
		[Description( "The service access point that is dependent on an underlying SAP."): 
		ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_ServiceAccessPoint ref Dependent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Often, an alarm device is installed as part of a package, not to "
				"indicate issues with any particular logical device or physical component, "
				"but with the package's environment in general, its security state or its "
				"overall health. This relationship is described by the CIM_PackageAlarm association. "
				""): ToSubclass, DisplayName{ "CIM_PackageAlarm"}, Locale( 1033), UUID( "{FAF76B90-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PackageAlarm:CIM_Dependency
{
		[Description( "The alarm device for the package. "): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_AlarmDevice ref Antecedent;
		[Description( "The physical package whose health, security, environment, etc. "
				"is alarmed. "): ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), 
		PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref Dependent;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( "A link between "
				"a process and a data file indicating that the file participates in the execution "
				"of the process."): ToSubclass, DisplayName{ "CIM_ProcessExecutable"}, dynamic: 
		ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), UUID( "{8502C542-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_ProcessExecutable"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_ProcessExecutable:CIM_Dependency
{
		[Description( "The data file participating in the execution of the process."): 
		ToSubclass, DisplayName{ "Antecedent"}, 
		PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_DataFile ref Antecedent;
		[Description( "BaseAddress represents the base address of the module in the address "
				"space of the associated process."): ToSubclass, DisplayName{ "BaseAddress"}, 
		PropertySources{ "BaseAddress"}: ToSubclass, read: ToSubclass, Schema( "Win32"): 
		ToInstance]
	UINT64 BaseAddress;
		[Description( "The process."): ToSubclass, DisplayName{ "Dependent"}, 
		PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_Process ref Dependent;
		[Description( "GlobalProcessCount is the current number of processes that have "
				"the file loaded in memory."): ToSubclass, DisplayName{ "GlobalProcessCount"}, 
		PropertySources{ "GlobalProcessCount"}: ToSubclass, read: ToSubclass, Schema( 
		"Win32"): ToInstance]
	UINT32 GlobalProcessCount;
		[DEPRECATED: ToSubclass, Description( "ModuleInstance represents the Win32 instance "
				"handle.The ModuleInstance property has been deprecated.  There is no replacement "
				"value and this property is now considered obsolete."): ToSubclass, DisplayName{ 
		"ModuleInstance"}, PropertySources{ "ModuleInstance"}: ToSubclass, read: ToSubclass, 
		Schema( "Win32"): ToInstance]
	UINT32 ModuleInstance;
		[Description( "ProcessCount represents the reference count of the file in the "
				"associated process."): ToSubclass, DisplayName{ "ProcessCount"}, PropertySources{ 
		"ProcessCount"}: ToSubclass, read: ToSubclass, Schema( "Win32"): ToInstance]
	UINT32 ProcessCount;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Logical "
				"devices may have one or more alarm devices associated with them, in order "
				"to indicate problem situations. This relationship is indicated by the CIM_AssociatedAlarm "
				"dependency. "): ToSubclass, DisplayName{ "CIM_AssociatedAlarm"}, Locale( 
		1033), UUID( "{2280CB02-DB35-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_AssociatedAlarm:CIM_Dependency
{
		[Description( "The alarm device. "): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_AlarmDevice ref Antecedent;
		[Description( "The logical device that is alarmed. "): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a service and how it is implemented. The cardinality "
				"of this association is many-to-many. A service may be provided by more than "
				"one logical device, operating in conjunction.  And, any device may provide "
				"more than one service.  When multiple devices are associated with a single "
				"service, it is assumed that these elements operate in conjunction to provide "
				"the service.  If different implementations of a service exist, each of these "
				"implementations would result in individual instantiations of the service "
				"object.  These individual instantiations would then have associations to "
				"the unique implementations."): ToSubclass, DisplayName{ "CIM_DeviceServiceImplementation"}, 
		Locale( 1033), UUID( "{290FC242-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_DeviceServiceImplementation:CIM_Dependency
{
		[Description( "The logical device."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Antecedent;
		[Description( "The service implemented using the logical device."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Service ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ConnectedTo association indicates that two or more physical connectors "
				"are connected together."): ToSubclass, DisplayName{ "CIM_ConnectedTo"}, Locale( 
		1033), UUID( "{FAF76B85-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ConnectedTo:CIM_Dependency
{
		[Description( "The Antecedent represents a physical connector that serves as one "
				"end of the connection."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalConnector ref Antecedent;
		[Description( "The Dependent represents another physical connector that serves "
				"as the other end of the connection."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalConnector ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Slots "
				"are special types of connectors into which adapter cards are typically inserted. "
				"The CIM_SlotInSlot relationship represents the ability of a special adapter "
				"to extend the existing slot structure to enable otherwise incompatible cards "
				"to be plugged into a frame or hosting board. The adapter effectively creates "
				"a new slot and can be thought of (conceptually) as a slot in a slot. This "
				"enables cards that would otherwise be physically and/or electrically incompatible "
				"with the existing slots to be supported, by interfacing to the slot provided "
				"by the adapter. This has many practical uses. For example, networking boards "
				"are very expensive. As new hardware becomes available, chassis and even card "
				"configurations change. To protect the investment of their customers, networking "
				"vendors will manufacture special adapters that enable old cards to fit into "
				"new chassis or HostingBoards and/or new cards to fit into old. This is done "
				"using a special adapter that fits over one or more existing slots and presents "
				"a new slot into which the card can plug."): ToSubclass, DisplayName{ "CIM_SlotInSlot"}, 
		Locale( 1033), UUID( "{FAF76B87-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_SlotInSlot:CIM_ConnectedTo
{
		[Description( "The Antecedent reference represents the existing slot(s) of the "
				"hosting board, or frame that are being adapted to accommodate a card that "
				"would otherwise not be physically and/or electrically compatible with it."): 
		ToSubclass, DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Slot ref Antecedent;
		[Description( "The new slot provided by the adapter board."): ToSubclass, DisplayName{ 
		"Dependent"}, Max( 1): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Slot ref Dependent;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( "CIM_Realizes "
				"is the association that defines the mapping between a logical device and "
				"the physical component that implements the device."): ToSubclass, DisplayName{ 
		"CIM_Realizes"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		UUID( "{FAF76B62-798C-11D2-AAD1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_Realizes"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_Realizes:CIM_Dependency
{
		[Description( "The physical component that implements the device."): ToSubclass, 
		DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref Antecedent;
		[Description( "The logical device."): ToSubclass, DisplayName{ "Dependent"}, Override( 
		"Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_HostedAccessPoint "
				"is an association between a serviceaccess point 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 service access points. "
				" Heuristic:  If the implementation of the service access point is modeled, "
				"it must be implemented by a device or software feature that is part of the "
				"system hosting the service access point."): ToSubclass, DisplayName{ "CIM_HostedAccessPoint"}, 
		Locale( 1033), UUID( "{576C3C56-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_HostedAccessPoint:CIM_Dependency
{
		[Description( "The hosting system."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_System ref Antecedent;
		[Description( "The SAP(s) that are hosted on this system."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass, Weak: ToSubclass]
	CIM_ServiceAccessPoint ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_RunningOS "
				"indicates the currently executing operating system. At most one operating "
				"system can execute at any time on a computer system. 'At most one' is specified, "
				"since the computer system may not be currently booted, or its operating system "
				"may be unknown."): ToSubclass, DisplayName{ "CIM_RunningOS"}, Locale( 1033), 
		UUID( "{1F2EA300-DB37-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_RunningOS:CIM_Dependency
{
		[Description( "The operating system currently running on the computer system."): 
		ToSubclass, DisplayName{ "Antecedent"}, Max( 1): ToSubclass, Override( "Antecedent"), 
		PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_OperatingSystem ref Antecedent;
		[Description( "The computer system."): ToSubclass, DisplayName{ "Dependent"}, 
		Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a FileSystem and the StorageExtent where it is located. "
				"Typically, a FileSystem ResidesOn a LogicalDisk."): ToSubclass, DisplayName{ 
		"CIM_ResidesOnExtent"}, Locale( 1033), UUID( "{10458E26-DB37-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ResidesOnExtent:CIM_Dependency
{
		[Description( "The storage extent."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_StorageExtent ref Antecedent;
		[Description( "The file system that is located on the storage extent."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_FileSystem ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_MemoryWithMedia "
				"indicates that memory is associated with a physical media and its cartridge. "
				"The memory provides media identification and also stores user-specific data. "
				""): ToSubclass, DisplayName{ "CIM_MemoryWithMedia"}, Locale( 1033), UUID( 
		"{FAF76B7E-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_MemoryWithMedia:CIM_Dependency
{
		[Description( "The memory associated with physical media. "): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_PhysicalMemory ref Antecedent;
		[Description( "The physical media."): ToSubclass, DisplayName{ "Dependent"}, Override( 
		"Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalMedia ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association describing where a job is submitted for processing, i.e. to which "
				"job destination."): ToSubclass, DisplayName{ "CIM_JobDestinationJobs"}, Locale( 
		1033), UUID( "{8D079BEE-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_JobDestinationJobs:CIM_Dependency
{
		[Description( "The job destination, possibly a queue."): ToSubclass, DisplayName{ 
		"Antecedent"}, Max( 1): ToSubclass, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_JobDestination ref Antecedent;
		[Description( "The job that is in the job queue/Destination."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Job ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( " "
				"An association between a service access point and how it is   implemented "
				"in software.  The cardinality of this association  is many-to-many.  A SAP "
				"may be provided by more than one  software feature, operating in conjunction. "
				" And, any  software feature may provide more than one service access point. "
				"a  When many software features are associated with single SAP,  it is assumed "
				"that these elements operate in conjunction to  provide the access point. "
				" If different implementations of a  SAP exist, each of these implementations "
				"would result in  individual instantiations of the service access point object. "
				" These individual instantiations would then have associations  to the unique "
				"implementations. "): ToSubclass, DisplayName{ "CIM_SoftwareFeatureSAPImplementation"}, 
		Locale( 1033), UUID( "{7EFCC186-DB37-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_SoftwareFeatureSAPImplementation:CIM_Dependency
{
		[Description( "The antecedent software feature."): ToSubclass, DisplayName{ "Antecedent"}, 
		Min( 0): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_SoftwareFeature ref Antecedent;
		[Description( "The dependent service access point."): ToSubclass, DisplayName{ 
		"Dependent"}, Min( 0): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_ServiceAccessPoint ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Similar "
				"to the way that logical devices are 'Realized' by physical elements, unitary "
				"computer systems are realized in one or more physical packages. The CIM_ComputerSystemPackage "
				"association explicitly defines this relationship."): ToSubclass, DisplayName{ 
		"CIM_ComputerSystemPackage"}, Locale( 1033), UUID( "{FAF76B8D-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_ComputerSystemPackage:CIM_Dependency
{
		[Description( "The physical package(s) that realize a unitary computer system."): 
		ToSubclass, DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref Antecedent;
		[Description( "The unitary computer system."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_UnitaryComputerSystem ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Many "
				"devices include sensors or have sensors installed nearby, in order to measure "
				"critical input and output properties.  This association indicates that relationship."): 
		ToSubclass, DisplayName{ "CIM_AssociatedSensor"}, Locale( 1033), UUID( "{956597A0-7D80-11D2-AAD3-006008C78BC7}"): 
		ToInstance]
class CIM_AssociatedSensor:CIM_Dependency
{
		[Description( "The sensor."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Sensor ref Antecedent;
		[Description( "The logical device for which information is measured by the sensor."): 
		ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"power supply may have an associated voltage sensor, monitoring its input "
				"voltage. This is described by this association."): ToSubclass, DisplayName{ 
		"CIM_AssociatedSupplyVoltageSensor"}, Locale( 1033), UUID( "{327ABD78-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_AssociatedSupplyVoltageSensor:CIM_AssociatedSensor
{
		[Description( "The voltage sensor."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_VoltageSensor ref Antecedent;
		[Description( "The power supply associated with the voltage sensor."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PowerSupply ref Dependent;
		[Description( "Indicates the power supply's input voltage range measured by the "
				"associated sensor. Range 1, 2 or both can be specified using the values 2, "
				"3 or 4, respectively."): ToSubclass, DisplayName{ "MonitoringRange"}, PropertySources{ 
		"MonitoringRange"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", 
		"Range 1", "Range 2", "Both Range 1 and 2"}: ToSubclass]
	UINT16 MonitoringRange;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "A "
				"power supply may have an associated current sensor, monitoring its input "
				"frequency. This is described by this association."): ToSubclass, DisplayName{ 
		"CIM_AssociatedSupplyCurrentSensor"}, Locale( 1033), UUID( "{29B273F2-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_AssociatedSupplyCurrentSensor:CIM_AssociatedSensor
{
		[Description( "The current sensor."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_CurrentSensor ref Antecedent;
		[Description( "The power supply associated with the current sensor."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PowerSupply ref Dependent;
		[Description( "Indicates the power supply's input frequency range measured by "
				"the associated sensor. Range 1, 2 or both can be specified using the values "
				"2, 3 or 4, respectively."): ToSubclass, DisplayName{ "MonitoringRange"}, 
		PropertySources{ "MonitoringRange"}: ToSubclass, read: ToSubclass, Values{ "Unknown", 
		"Other", "Range 1", "Range 2", "Both Range 1 and 2"}: ToSubclass]
	UINT16 MonitoringRange;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( "CIM_ServiceServiceDependency "
				"is an association between a service and another service, indicating that "
				"the latter is required to be present, required to have completed, or must "
				"be absent for the former service to provide its functionality. For example, "
				"boot services may be dependent upon underlying BIOS Disk and initialization "
				"services. In the case of the initialization services, the boot service is "
				"simply dependent on the init services completing.  For the disk services, "
				"boot services may actually utilize the SAPs of this service.  This usage "
				"dependency is modeled via the CIM_ServiceSAPDependency association."): ToSubclass, 
		DisplayName{ "CIM_ServiceServiceDependency"}, Locale( 1033), UUID( "{8502C53B-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_ServiceServiceDependency:CIM_Dependency
{
		[Description( "The required service."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Service ref Antecedent;
		[Description( "The service that is dependent on an underlying service."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Service ref Dependent;
		[Description( "The nature of the service to service dependency. This property "
				"describes that the associated service must have completed (value=2), must "
				"be started (3) or must not be started (4) in order for the service to function."): 
		ToSubclass, DisplayName{ "TypeOfDependency"}, PropertySources{ "TypeOfDependency"}: 
		ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Service Must Have "
				"Completed", "Service Must Be Started", "Service Must Not Be Started"}: ToSubclass]
	UINT16 TypeOfDependency;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_DeviceConnection relationship indicates that two or more device are connected "
				"together."): ToSubclass, DisplayName{ "CIM_DeviceConnection"}, Locale( 1033), 
		UUID( "{8502C53C-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_DeviceConnection:CIM_Dependency
{
		[Description( "A logical device."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Antecedent;
		[Description( "A second logical device connected to the Antecedent device."): 
		ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
		[Description( "When several bus and/or connection data widths are possible, the "
				"NegotiatedDataWidth property defines the one in use between the devices. "
				" Data width is specified in bits.  If data width is not negotiated, or if "
				"this information is not available/important to device management, the property "
				"should be set to 0."): ToSubclass, DisplayName{ "NegotiatedDataWidth"}, PropertySources{ 
		"NegotiatedDataWidth"}: ToSubclass, read: ToSubclass, Units( "Bits"): ToSubclass]
	UINT32 NegotiatedDataWidth;
		[Description( "When several bus and/or connection speeds are possible, the NegotiatedSpeed "
				"property defines the one in use between the devices.  Speed is specified "
				"in bits per second.  If connection or bus speeds are not negotiated, or if "
				"this information is not available/important to device management, the property "
				"should be set to 0."): ToSubclass, DisplayName{ "NegotiatedSpeed"}, PropertySources{ 
		"NegotiatedSpeed"}: ToSubclass, read: ToSubclass, Units( "Bits per Second"): 
		ToSubclass]
	UINT64 NegotiatedSpeed;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ControlledBy relationship indicates which devices are commanded by or "
				"accessed through the controller logical device."): ToSubclass, DisplayName{ 
		"CIM_ControlledBy"}, Locale( 1033), UUID( "{8502C53D-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance]
class CIM_ControlledBy:CIM_DeviceConnection
{
		[Description( "The AccessState property indicates whether the controller is actively "
				"commanding or accessing the device (value=1) or not (value=2).  Also, the "
				"value, \"Unknown\" (0), can be defined. This information is necessary when "
				"a logical device can be commanded by, or accessed through, multiple controllers."): 
		ToSubclass, DisplayName{ "AccessState"}, PropertySources{ "AccessState"}: ToSubclass, 
		read: ToSubclass, Values{ "Unknown", "Active", "Inactive"}: ToSubclass]
	UINT16 AccessState;
		[Description( "The controller."): ToSubclass, DisplayName{ "Antecedent"}, Override( 
		"Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_Controller ref Antecedent;
		[Description( "The controlled device."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
		[Description( "Number of hard resets issued by the controller. A hard reset returns "
				"the device to its initialization or 'boot-up' state. All internal device "
				"state information and data are lost."): ToSubclass, DisplayName{ "NumberOfHardResets"}, 
		PropertySources{ "NumberOfHardResets"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfHardResets;
		[Description( "Number of soft resets issued by the controller. A soft reset does "
				"not completely clear current device state and/or data. Exact semantics are "
				"dependent on the device, and on the protocols and mechanisms used to communicate "
				"to it."): ToSubclass, DisplayName{ "NumberOfSoftResets"}, PropertySources{ 
		"NumberOfSoftResets"}: ToSubclass, read: ToSubclass]
	UINT32 NumberOfSoftResets;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_SCSIInterface "
				"is a CIM_ControlledBy relationship indicating which devices are accessed "
				"through a SCSI controller and the characteristics of this access."): ToSubclass, 
		DisplayName{ "CIM_SCSIInterface"}, Locale( 1033), UUID( "{7CE7448E-E3D4-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_SCSIInterface:CIM_ControlledBy
{
		[Description( "The SCSI controller."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_SCSIController ref Antecedent;
		[Description( "The logical device."): ToSubclass, DisplayName{ "Dependent"}, Override( 
		"Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
		[Description( "Number of SCSI retries that have occurred since last hard or soft "
				"reset related to the controlled Device. The time of last reset is indicated "
				"in the TimeOfDeviceReset property, inherited from the ControlledBy association."): 
		ToSubclass, DisplayName{ "SCSIRetries"}, PropertySources{ "SCSIRetries"}: ToSubclass, 
		read: ToSubclass]
	UINT32 SCSIRetries;
		[Description( "Number of SCSI timeouts that have occurred since last hard or soft "
				"reset related to the controlled Device. The time of last reset is indicated "
				"in the TimeOfDeviceReset property, inherited from the ControlledBy association."): 
		ToSubclass, DisplayName{ "SCSITimeouts"}, PropertySources{ "SCSITimeouts"}: ToSubclass, 
		read: ToSubclass]
	UINT32 SCSITimeouts;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_SerialInterface "
				"is a CIM_ControlledBy relationship indicating which devices are accessed "
				"through the serial controller and the characteristics of this access."): 
		ToSubclass, DisplayName{ "CIM_SerialInterface"}, Locale( 1033), UUID( "{8B309BDA-E3D4-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_SerialInterface:CIM_ControlledBy
{
		[Description( "The serial controller."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_SerialController ref Antecedent;
		[Description( "The logical device."): ToSubclass, DisplayName{ "Dependent"}, Override( 
		"Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
		[Description( "An integer enumeration indicating the flow control (Xon-Xoff and/or "
				"RTS/CTS) for transmitted data."): ToSubclass, DisplayName{ "FlowControlInfo"}, 
		PropertySources{ "FlowControlInfo"}: ToSubclass, read: ToSubclass, Values{ "Unknown", 
		"Not Supported", "None", "XonXoff", "RTS/CTS", "Both XonXoff and RTS/CTS"}: ToSubclass]
	UINT16 FlowControlInfo;
		[Description( "Number of stop bits to be transmitted."): ToSubclass, DisplayName{ 
		"NumberOfStopBits"}, PropertySources{ "NumberOfStopBits"}: ToSubclass, read: 
		ToSubclass, Units( "Bits"): ToSubclass]
	UINT16 NumberOfStopBits;
		[Description( "Information on the parity setting for transmitted data. No parity "
				"(value=1), even (2) or odd (3) can be specified."): ToSubclass, DisplayName{ 
		"ParityInfo"}, PropertySources{ "ParityInfo"}: ToSubclass, read: ToSubclass, 
		Values{ "Unknown", "None", "Even", "Odd"}: ToSubclass]
	UINT16 ParityInfo;
};
	[Association: ToInstance  ToSubclass, Description( "USBControllerHasHub "
				"defines the Hub(s) that are downstream of the USBController."): ToSubclass, 
		DisplayName{ "CIM_USBControllerHasHub"}, dynamic: ToInstance, LOCALE( 1033), 
		provider( "MS_VIEW_INSTANCE_PROVIDER"), ViewSources{ "SELECT * FROM CIM_USBControllerHasHub"}, 
		ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_USBControllerHasHub:CIM_ControlledBy
{
		[Description( "The USBController."): ToSubclass, DisplayName{ "Antecedent"}, Max( 
		1): ToSubclass, Min( 1): ToSubclass, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_USBController ref Antecedent;
		[Description( "The USBHub that is associated with the Controller."): ToSubclass, 
		DisplayName{ "Dependent"}, Min( 1): ToSubclass, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_USBHub ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a job destination and a system on which it resides. The "
				"cardinality of this association is 1-to-many.  A system may host many job "
				"queues. Job destinations are weak with respect to their hosting system. Heuristic: "
				"A job destination is hosted on the system where the logical devices, software "
				"features or services that implement/provide the job destination are located."): 
		ToSubclass, DisplayName{ "CIM_HostedJobDestination"}, Locale( 1033), UUID( "{7880DD16-DB36-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_HostedJobDestination:CIM_Dependency
{
		[Description( "The hosting system."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_System ref Antecedent;
		[Description( "The job destination hosted on the system."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass, Weak: ToSubclass]
	CIM_JobDestination ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, 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 logical devices or "
				"software features that implement the service are located.  The model does "
				"not represent services hosted across multiple systems.  This is modeled as "
				"an application system that acts as an aggregation point for services, that "
				"are each located on a single host."): ToSubclass, DisplayName{ "CIM_HostedService"}, 
		Locale( 1033), UUID( "{83B2A7AA-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_HostedService:CIM_Dependency
{
		[Description( "The hosting system."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "Antecedent"), PropertySources{ 
		"Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_System ref Antecedent;
		[Description( "The service hosted on the system."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass, 
		Weak: ToSubclass]
	CIM_Service ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_BasedOn "
				"is an association describing how storage extents can be assembled from lower "
				"level extents. For example, protected space extents are parts of physical "
				"extents, while volume sets are assembled from one or more physical or protected "
				"space extents. As another example, cache memory can be defined independently "
				"and realized in a physical element or can be 'based on' volatile or non-volatile "
				"storage extents."): ToSubclass, DisplayName{ "CIM_BasedOn"}, Locale( 1033), 
		UUID( "{8502C53E-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_BasedOn:CIM_Dependency
{
		[Description( "The lower level storage extent."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_StorageExtent ref Antecedent;
		[Description( "The higher level storage extent."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_StorageExtent ref Dependent;
		[Description( "EndingAddress indicates where in lower level storage, the higher "
				"level extent ends. This property is useful when mapping non-contiguous extents "
				"into a higher level grouping."): ToSubclass, DisplayName{ "EndingAddress"}, 
		PropertySources{ "EndingAddress"}: ToSubclass, read: ToSubclass]
	UINT64 EndingAddress;
		[Description( "StartingAddress indicates where in lower level storage, the higher "
				"level extent begins."): ToSubclass, DisplayName{ "StartingAddress"}, PropertySources{ 
		"StartingAddress"}: ToSubclass, read: ToSubclass]
	UINT64 StartingAddress;
};
	[Association: ToInstance  ToSubclass, Description( "LogicalDisks "
				"can be BasedOn a DiskPartition. For example, a personal computer's C: drive "
				"may be located on a Partition on local PhysicalMedia. In this association "
				"of LogicalDisks to Partitions, note that the cardinality of the Antecedent, "
				"DiskPartition, is Max(1). This dictates that a LogicalDisk can not span more "
				"than one Partition. However, there are cases where this is true. When it "
				"occurs, the LogicalDisk is really based on some kind of RAID configuration "
				"(for example, a mirror or stripe set). In these scenarios, the LogicalDisk "
				"is more correctly BasedOn a StorageVolume. To prevent incorrectly using the "
				"LogicalDiskBasedOnPartition association, the Max(1) qualifier was put on "
				"the Antecedent reference to the DiskPartition."): ToSubclass, DisplayName{ 
		"CIM_LogicalDiskBasedOnPartition"}, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), UUID( "{8502C53F-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_LogicalDiskBasedOnPartition"}, ViewSpaces{ 
		"\\\\.\\root\\cimv2"}]
class CIM_LogicalDiskBasedOnPartition:CIM_BasedOn
{
		[Description( "The disk partition."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_DiskPartition ref Antecedent;
		[Description( "The logical disk which is built on the partition."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_LogicalDisk ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "LogicalDisks "
				"can be BasedOn a single Volume (for example, exposed by a software volume "
				"manager), or be BasedOn a DiskPartition directly. The former relationship "
				"is made explicit in this association."): ToSubclass, DisplayName{ "CIM_LogicalDiskBasedOnVolumeSet"}, 
		Locale( 1033), UUID( "{3A608798-E3D3-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_LogicalDiskBasedOnVolumeSet:CIM_BasedOn
{
		[Description( "The volume set."): ToSubclass, DisplayName{ "Antecedent"}, Max( 
		1): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_VolumeSet ref Antecedent;
		[Description( "The logical disk which is built on the volume set."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_LogicalDisk ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Protected "
				"space extents are based on a physical extent. This relationship is made explicit "
				"in this association."): ToSubclass, DisplayName{ "CIM_PSExtentBasedOnPExtent"}, 
		Locale( 1033), UUID( "{451FE14C-E3D3-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_PSExtentBasedOnPExtent:CIM_BasedOn
{
		[Description( "The physical extent."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalExtent ref Antecedent;
		[Description( "The protected space extent which is built on the physical extent."): 
		ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_ProtectedSpaceExtent ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a service access point and how it is implemented. The "
				"cardinality of this association is many-to-many.  A SAP may be provided by "
				"more than one logical device, operating in conjunction.  And, any device "
				"may provide more than one service access point. When many logical devices "
				"are associated with a single SAP, it is assumed that these elements operate "
				"in conjunction to provide the access point.  If different implementations "
				"of a SAP exist, each of these implementations would result in individual "
				"instantiations of the service access point object.  These individual instantiations "
				"would then have associations to the unique implementations."): ToSubclass, 
		DisplayName{ "CIM_DeviceSAPImplementation"}, Locale( 1033), UUID( "{1BE949DA-DB36-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_DeviceSAPImplementation:CIM_Dependency
{
		[Description( "The logical device."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Antecedent;
		[Description( "The service access point implemented using the logical device."): 
		ToSubclass, DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ 
		"Dependent"}: ToSubclass, read: ToSubclass]
	CIM_ServiceAccessPoint ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_DeviceSoftware relationship identifies any software that is associated "
				"with a device - such as drivers, configuration or application software, or "
				"firmware."): ToSubclass, DisplayName{ "CIM_DeviceSoftware"}, Locale( 1033), 
		UUID( "{36363AAA-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_DeviceSoftware:CIM_Dependency
{
		[Description( "The software element."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_SoftwareElement ref Antecedent;
		[Description( "The logical device that requires or uses the software."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
		[Description( "An enumerated integer to indicate the role this software plays "
				"in regards to its associated device. For example, this software could be "
				"instrumentation (value=5) or firmware (6)."): ToSubclass, DisplayName{ "Purpose"}, 
		ModelCorrespondence{ "CIM_DeviceSoftware.PurposeDescription"}: ToSubclass, PropertySources{ 
		"Purpose"}: ToSubclass, read: ToSubclass, Values{ "Unknown", "Other", "Driver", 
		"Configuration Software", "Application Software", "Instrumentation", "Firmware", 
		"BIOS", "Boot ROM"}: ToSubclass]
	UINT16 Purpose;
		[Description( "A free-form string to provide more information for the Purpose "
				"property, e.g. \"Application Software\"."): ToSubclass, DisplayName{ "PurposeDescription"}, 
		ModelCorrespondence{ "CIM_DeviceSoftware.Purpose"}: ToSubclass, PropertySources{ 
		"PurposeDescription"}: ToSubclass, read: ToSubclass]
	STRING PurposeDescription;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Many "
				"devices, such as processors or power supplies, require their own cooling "
				"devices.  This association indicates where fans or other cooling devices "
				"are specific to a device, versus providing enclosure or cabinet cooling."): 
		ToSubclass, DisplayName{ "CIM_AssociatedCooling"}, Locale( 1033), UUID( "{306F88F2-DB35-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_AssociatedCooling:CIM_Dependency
{
		[Description( "The cooling device."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_CoolingDevice ref Antecedent;
		[Description( "The logical device being cooled."): ToSubclass, DisplayName{ "Dependent"}, 
		Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a FileSystem and a Directory which indicates that the "
				"Directory is being attached to the FileSystem. The semantics of this relationship "
				"require that the mounted Directory be contained by a FileSystem (via the "
				"FileStorage association) that is different from the FileSystem referenced "
				"as the Dependent. The Directory's containing FileSystem could be either local "
				"or remote. For example, a LocalFileSystem on a Solaris ComputerSystem can "
				"mount a Directory from the FileSystem accessed via the machine's CDROM drive, "
				"i.e., another LocalFileSystem. On the other hand, in a 'remote' case, the "
				"Directory is first exported by its FileSystem, which is hosted on another "
				"ComputerSystem acting (for example) as a file server. In order to distinguish "
				"these two types of Mount, it is recommended that a CIM_Export association "
				"always be defined for the remotely accessed/mounted Directories."): ToSubclass, 
		DisplayName{ "CIM_Mount"}, Locale( 1033), UUID( "{75BCF4F6-DB46-11D2-B4C8-80080C7B6371}"): 
		ToInstance]
class CIM_Mount:CIM_Dependency
{
		[Description( "The directory mounted."): ToSubclass, DisplayName{ "Antecedent"}, 
		Max( 1): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Directory ref Antecedent;
		[Description( "The FileSystem the Directory is mounted on."): ToSubclass, DisplayName{ 
		"Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_NFS ref Dependent;
};
	[Association: ToInstance  ToSubclass, Description( "Where a storage "
				"extent must be accessed through a media access device, this relationship "
				"is described by the CIM_MediaPresent association."): ToSubclass, DisplayName{ 
		"CIM_MediaPresent"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		UUID( "{8502C540-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_MediaPresent"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_MediaPresent:CIM_Dependency
{
		[Description( "The media access device."): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_MediaAccessDevice ref Antecedent;
		[Description( "The storage extent accessed using the media access device."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_StorageExtent ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ServiceSAPDependency "
				"is an association between a service and a service access point indicating "
				"that the referenced SAP is utilized by the service to provide its functionality. "
				"For example, boot services may invoke BIOS' disk services (interrupts) in "
				"order to function."): ToSubclass, DisplayName{ "CIM_ServiceSAPDependency"}, 
		Locale( 1033), UUID( "{652E2D58-DB37-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ServiceSAPDependency:CIM_Dependency
{
		[Description( "The required service access point"): ToSubclass, DisplayName{ "Antecedent"}, 
		Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, read: ToSubclass]
	CIM_ServiceAccessPoint ref Antecedent;
		[Description( "The service that is dependent on an underlying SAP."): ToSubclass, 
		DisplayName{ "Dependent"}, Override( "Dependent"), PropertySources{ "Dependent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Service ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Complex "
				"networking devices often are chassis-based. These chassis allow for enhancement "
				"and/or augmentation of their base functionality by accepting additional chassis "
				"devices, similar to accepting functionality in the form of adding cards. "
				"This association models this capability."): ToSubclass, DisplayName{ "CIM_PackageInSlot"}, 
		Locale( 1033), UUID( "{FAF76B89-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_PackageInSlot:CIM_Dependency
{
		[Description( "The slot into which the physical package is inserted."): ToSubclass, 
		DisplayName{ "Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Slot ref Antecedent;
		[Description( "The package in the slot."): ToSubclass, DisplayName{ "Dependent"}, 
		Max( 1): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_PhysicalPackage ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "Slots "
				"are special types of connectors into which adapter cards are inserted. This "
				"relationship of a card in a slot is made explicit using the CIM_CardInSlot "
				"association."): ToSubclass, DisplayName{ "CIM_CardInSlot"}, Locale( 1033), 
		MappingStrings{ "MIF.DMTF|System Slot|004.4"}: ToSubclass, UUID( "{FAF76B8A-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_CardInSlot:CIM_PackageInSlot
{
		[Description( "The slot into which the card is inserted."): ToSubclass, DisplayName{ 
		"Antecedent"}, Override( "Antecedent"), PropertySources{ "Antecedent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Slot ref Antecedent;
		[Description( "The card in the slot."): ToSubclass, DisplayName{ "Dependent"}, 
		Max( 1): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Card ref Dependent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( " "
				"An association between a service and how it is implemented in software.  "
				"The cardinality of this association is many-to-many.  A service may be  provided "
				"by more than one software feature, operating in conjunction.   And, any software "
				"Feature may provide more than one service.  When  multiple software features "
				"are associated with a single service, it is  assumed that these elements "
				"operate in conjunction to provide the  service.  If different implementations "
				"of a service exist, each of  these implementations would result in individual "
				"instantiations of the  service object.  These individual instantiations would "
				"then have  associations to the unique implementations. "): ToSubclass, DisplayName{ 
		"CIM_SoftwareFeatureServiceImplementation"}, Locale( 1033), UUID( "{8AC984F4-DB37-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_SoftwareFeatureServiceImplementation:CIM_Dependency
{
		[Description( "The antecedent software feature."): ToSubclass, DisplayName{ "Antecedent"}, 
		Min( 0): ToSubclass, Override( "Antecedent"), PropertySources{ "Antecedent"}: 
		ToSubclass, read: ToSubclass]
	CIM_SoftwareFeature ref Antecedent;
		[Description( "The dependent service."): ToSubclass, DisplayName{ "Dependent"}, 
		Min( 0): ToSubclass, Override( "Dependent"), PropertySources{ "Dependent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Service ref Dependent;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( "CIM_ProvidesServiceToElement "
				"is used to describe that ManagedElements may be dependent on the functionality "
				"of one or more Services. An example is that a Processor and an Enclosure "
				"(PhysicalElement) are dependent on AlertOnLAN Services to signal an incomplete "
				"or erroneous boot, and hardware-related errors.")]
class CIM_ProvidesServiceToElement:CIM_Dependency
{
		[Description( "The Service provided."), Override( "Antecedent")]
	CIM_Service ref Antecedent;
		[Description( "The ManagedElement dependent on the Service."), Override( "Dependent")]
	CIM_ManagedElement ref Dependent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_ProductParentChild association defines a parent child hierarchy "
				"among products.  For example, a product may come bundled with other products. "
				""): ToSubclass, DisplayName{ "CIM_ProductParentChild"}, Locale( 1033), UUID( 
		"{3E24D5A6-DB2B-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ProductParentChild
{
		[Description( "The child product in the association."): ToSubclass, DisplayName{ 
		"Child"}, PropertySources{ "Child"}: ToSubclass, read: ToSubclass]
	CIM_Product ref Child;
		[Aggregate: ToSubclass, Description( "The parent product in the association."): 
		ToSubclass, DisplayName{ "Parent"}, PropertySources{ "Parent"}: ToSubclass, read: 
		ToSubclass]
	CIM_Product ref Parent;
};
	[Association: ToInstance  ToSubclass, Description( "CIM_LogicalIdentity "
				"is an abstract and generic association, indicating that two LogicalElements "
				"represent different aspects of the same underlying entity. This relationship "
				"conveys what could be defined with multiple inheritance. It is restricted "
				"to the 'logical' aspects of a ManagedSystemElement. In most scenarios, the "
				"Identity relationship is determined by the equivalence of Keys or some other "
				"identifying properties of the related Elements. The association should only "
				"be used in well understood scenarios. This is why the association is abstract "
				"- allowing more concrete definition and clarification in subclasses. One "
				"of the scenarios where this relationship is reasonable is to represent that "
				"a Device is both a 'bus' entity and a 'functional' entity. For example, a "
				"Device could be both a USB (bus) and a Keyboard (functional) entity."): ToSubclass, 
		DisplayName{ "CIM_LogicalIdentity"}, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), ViewSources{ "SELECT * FROM CIM_LogicalIdentity"}, 
		ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_LogicalIdentity
{
		[Description( "SameElement represents an alternate aspect of the System entity."): 
		ToSubclass, DisplayName{ "SameElement"}, key: DisableOverride  ToInstance  ToSubclass, 
		PropertySources{ "SameElement"}: ToSubclass]
	CIM_LogicalElement ref SameElement;
		[Description( "SystemElement represents one aspect of the LogicalElement."): ToSubclass, 
		DisplayName{ "SystemElement"}, key: DisableOverride  ToInstance  ToSubclass, 
		PropertySources{ "SystemElement"}: ToSubclass]
	CIM_LogicalElement ref SystemElement;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Indicates the physical elements that make up a FRU."): ToSubclass, 
		DisplayName{ "CIM_FRUPhysicalElements"}, Locale( 1033), UUID( "{977E36CA-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_FRUPhysicalElements
{
		[Description( "The physical element which is a part of the FRU."): ToSubclass, 
		DisplayName{ "Component"}, PropertySources{ "Component"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref Component;
		[Aggregate: ToSubclass, Description( "The FRU."): ToSubclass, DisplayName{ "FRU"}, 
		Max( 1): ToSubclass, PropertySources{ "FRU"}: ToSubclass, read: ToSubclass]
	CIM_FRU ref FRU;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_RelatedStatistics "
				"is an association that defines hierarchies and/or dependencies of related "
				"CIM_StatisticalInformation classes."): ToSubclass, DisplayName{ "CIM_RelatedStatistics"}, 
		Locale( 1033), UUID( "{956597A4-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_RelatedStatistics
{
		[Description( "The related statistics or metrics."): ToSubclass, DisplayName{ 
		"RelatedStats"}, PropertySources{ "RelatedStats"}: ToSubclass, read: ToSubclass]
	CIM_StatisticalInformation ref RelatedStats;
		[Description( "The statistic information/object."): ToSubclass, DisplayName{ "Stats"}, 
		PropertySources{ "Stats"}: ToSubclass, read: ToSubclass]
	CIM_StatisticalInformation ref Stats;
};
	[Abstract, Association: ToInstance  ToSubclass, Description( " The CIM_InstalledSoftwareElement "
				"association allows one to identify the computer system a particular software "
				"element is installed on. "): ToSubclass, DisplayName{ "CIM_InstalledSoftwareElement"}, 
		Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), UUID( 
		"{A7B05028-DB2A-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_InstalledSoftwareElement
{
		[Description( "References the software element that is installed."): ToSubclass, 
		DisplayName{ "Software"}, Max( FALSE): ToSubclass, Min( 0): ToSubclass, PropertySources{ 
		"Software"}: ToSubclass, read: ToSubclass]
	CIM_SoftwareElement ref Software;
		[Description( "References the computer system hosting a particular software element. "
				""): ToSubclass, DisplayName{ "System"}, Max( FALSE): ToSubclass, Min( 0): 
		ToSubclass, PropertySources{ "System"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref System;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ProductProductDependency "
				"is an association between two products, indicating that one must be installed, "
				"or must be absent, for the other to function. This is conceptually equivalent "
				"to the CIM_ServiceServiceDependency association."): ToSubclass, DisplayName{ 
		"CIM_ProductProductDependency"}, Locale( 1033), UUID( "{65878E68-DB2B-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ProductProductDependency
{
		[Description( "The product that is dependent on another product."): ToSubclass, 
		DisplayName{ "DependentProduct"}, PropertySources{ "DependentProduct"}: ToSubclass, 
		read: ToSubclass]
	CIM_Product ref DependentProduct;
		[Description( "The required product."): ToSubclass, DisplayName{ "RequiredProduct"}, 
		PropertySources{ "RequiredProduct"}: ToSubclass, read: ToSubclass]
	CIM_Product ref RequiredProduct;
		[Description( "The nature of the product dependency. This property describes that "
				"the associated product must be installed (value=2) or must be absent (value=3) "
				"in order for the product to function."): ToSubclass, DisplayName{ "TypeOfDependency"}, 
		PropertySources{ "TypeOfDependency"}: ToSubclass, read: ToSubclass, Values{ "Unknown", 
		"Other", "Product Must Be Installed", "Product Must Not Be Installed"}: ToSubclass]
	UINT16 TypeOfDependency;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ElementCapacity "
				"associates a CIM_PhysicalCapacity object with one or more physical elements. "
				"It serves to associate a description of min/max hardware requirements or "
				"capabilities (stored as a kind of CIM_PhysicalCapacity), with the physical "
				"elements being described."): ToSubclass, DisplayName{ "CIM_ElementCapacity"}, 
		Locale( 1033), UUID( "{FAF76B6A-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ElementCapacity
{
		[Description( "CIM_PhysicalCapacity describes the minimum and maximum requirements "
				"and ability to support different types of hardware for a physical element."): 
		ToSubclass, DisplayName{ "Capacity"}, PropertySources{ "Capacity"}: ToSubclass, 
		read: ToSubclass]
	CIM_PhysicalCapacity ref Capacity;
		[Description( "The physical element being described."): ToSubclass, DisplayName{ 
		"Element"}, Min( 1): ToSubclass, PropertySources{ "Element"}: ToSubclass, read: 
		ToSubclass]
	CIM_PhysicalElement ref Element;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ProductSupport "
				"is an association between product and support Access that conveys how support "
				"is obtained for the product.  This is a many-to-many relationship, implying "
				"that various types of support are available for a product, and that the same "
				"support object can provide assistance for multiple products."): ToSubclass, 
		DisplayName{ "CIM_ProductSupport"}, Locale( 1033), UUID( "{8D6D6880-DB2B-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ProductSupport
{
		[Description( "The product."): ToSubclass, DisplayName{ "Product"}, PropertySources{ 
		"Product"}: ToSubclass, read: ToSubclass]
	CIM_Product ref Product;
		[Description( "Support for the product."): ToSubclass, DisplayName{ "Support"}, 
		PropertySources{ "Support"}: ToSubclass, read: ToSubclass]
	CIM_SupportAccess ref Support;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "CIM_CollectedCollections is an aggregation association representing "
				"that a CollectionOfMSEs may itself be contained in a CollectionOfMSEs."): 
		ToSubclass, DisplayName{ "CIM_CollectedCollections"}, Locale( 1033)]
class CIM_CollectedCollections
{
		[Aggregate: ToSubclass, Description( "The 'higher level' or parent element in "
				"the aggregation."): ToSubclass, DisplayName{ "Collection"}, key: DisableOverride 
		 ToInstance  ToSubclass, PropertySources{ "Collection"}: ToSubclass]
	CIM_CollectionOfMSEs ref Collection;
		[Description( "The 'collected' Collection."): ToSubclass, DisplayName{ "CollectionInCollection"}, 
		key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "CollectionInCollection"}: 
		ToSubclass]
	CIM_CollectionOfMSEs ref CollectionInCollection;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "CIM_Component is a generic association used to establish 'part "
				"of' relationships between Managed System Elements. For example, the SystemComponent "
				"association defines parts of a System."): ToSubclass, DisplayName{ "CIM_Component"}, 
		Locale( 1033), UUID( "{8502C573-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_Component
{
		[Aggregate: ToSubclass, Description( "The parent element in the association."): 
		ToSubclass, DisplayName{ "GroupComponent"}, key: DisableOverride  ToInstance 
		 ToSubclass, PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref GroupComponent;
		[Description( "The child element in the association."): ToSubclass, DisplayName{ 
		"PartComponent"}, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ 
		"PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_RedundancyComponent class associates a redundancy group "
				"composed of managed system elements and indicates that these elements, taken "
				"together, provide redundancy. All elements aggregated in a redundancy group "
				"should be instantiations of the same object class."): ToSubclass, DisplayName{ 
		"CIM_RedundancyComponent"}, Locale( 1033), UUID( "{FB9D6E62-DB36-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_RedundancyComponent:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The CIM_RedundancyComponent association "
				"indicates that 'this set of fans' or 'these physical extents' participate "
				"in a single redundancy group."): ToSubclass, DisplayName{ "GroupComponent"}, 
		Override( "GroupComponent"), PropertySources{ "GroupComponent"}: ToSubclass, 
		read: ToSubclass]
	CIM_RedundancyGroup ref GroupComponent;
		[Description( "The child element in the association."): ToSubclass, DisplayName{ 
		"PartComponent"}, PropertySources{ "PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Describes the physical extents participating in a storage redundancy "
				"group."): ToSubclass, DisplayName{ "CIM_PExtentRedundancyComponent"}, Locale( 
		1033), UUID( "{AD3C1FA2-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_PExtentRedundancyComponent:CIM_RedundancyComponent
{
		[Aggregate: ToSubclass, Description( "The storage redundancy group."): ToSubclass, 
		DisplayName{ "GroupComponent"}, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_StorageRedundancyGroup ref GroupComponent;
		[Description( "The physical extent participating in the redundancy group."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalExtent ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Describes the aggregate physical extent in a storage redundancy "
				"group."): ToSubclass, DisplayName{ "CIM_AggregateRedundancyComponent"}, Locale( 
		1033), UUID( "{154E66D8-DB35-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_AggregateRedundancyComponent:CIM_RedundancyComponent
{
		[Aggregate: ToSubclass, Description( "The storage redundancy group."): ToSubclass, 
		DisplayName{ "GroupComponent"}, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_StorageRedundancyGroup ref GroupComponent;
		[Description( "The aggregate physical extent participating in the redundancy group."): 
		ToSubclass, DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ 
		"PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_AggregatePExtent ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Indicates the software features that make up the operating system. "
				"The software features can be part of different products."): ToSubclass, DisplayName{ 
		"CIM_OperatingSystemSoftwareFeature"}, Locale( 1033), UUID( "{96B4C734-DB36-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_OperatingSystemSoftwareFeature:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The operating system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Override( "GroupComponent"), PropertySources{ "GroupComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_OperatingSystem ref GroupComponent;
		[Description( "The software features that make up the operating system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_SoftwareFeature ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A link between the operating system and one or more processes running "
				"in the context of this operating system."): ToSubclass, DisplayName{ "CIM_OSProcess"}, 
		Locale( 1033), UUID( "{A361A7AE-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_OSProcess:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The operating system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_OperatingSystem ref GroupComponent;
		[Description( "The process running in the context of the operating system"): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_Process ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "CIM_SystemComponent is a specialization of the CIM_Component association "
				"that establishes 'part of' relationships between a System and the Managed "
				"System Elements of which it is composed."): ToSubclass, DisplayName{ "CIM_SystemComponent"}, 
		Locale( 1033), UUID( "{527BC6CE-BAFE-11d2-85E5-0000F8102E5F}"): ToInstance]
class CIM_SystemComponent:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The parent system in the association."): 
		ToSubclass, DisplayName{ "GroupComponent"}, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_System ref GroupComponent;
		[Description( "The child element that is a component of a system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref PartComponent;
};
		[abstract, Aggregation: ToSubclass, Association: ToInstance 
		ToSubclass, Description( "An association between a computer system and the system "
		"resources available on it."): ToSubclass, DisplayName{ "CIM_ComputerSystemResource"}, 
		Locale( 1033), UUID( "{9B81340A-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ComputerSystemResource:CIM_SystemComponent
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "A system resource of the computer system."): ToSubclass, DisplayName{ 
		"PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_SystemResource ref PartComponent;
};
		[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "An association between a computer system and the DMA channels available "
		"on it."): ToSubclass, DisplayName{ "CIM_ComputerSystemDMA"}, 
		Locale( 1033), UUID( "{9B81340B-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ComputerSystemDMA:CIM_ComputerSystemResource
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "A DMA channel of the computer system."): ToSubclass, DisplayName{ 
		"PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_DMA ref PartComponent;
};
		[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "An association between a computer system and the IRQs available "
		"on it."): ToSubclass, DisplayName{ "CIM_ComputerSystemIRQ"}, 
		Locale( 1033), UUID( "{A2EFC896-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ComputerSystemIRQ:CIM_ComputerSystemResource
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "An IRQ of the computer system."): ToSubclass, DisplayName{ "PartComponent"}, 
		Override( "PartComponent"), PropertySources{ "PartComponent"}: ToSubclass, read: 
		ToSubclass, Weak: ToSubclass]
	CIM_IRQ ref PartComponent;
};
		[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "An association between a computer system and the memory mapped "
		"I/O ports available on it."): ToSubclass, DisplayName{ "CIM_ComputerSystemMappedIO"}, 
		Locale( 1033), UUID("{A2EFC897-E3D3-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_ComputerSystemMappedIO:CIM_ComputerSystemResource
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "A memory mapped I/O port of the computer system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_MemoryMappedIO ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Logical devices may be aggregated by a system. This relationship "
				"is made explicit by the CIM_SystemDevice association. "): ToSubclass, DisplayName{ 
		"CIM_SystemDevice"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		UUID( "{4B2C30D7-BAFE-11d2-85E5-0000F8102E5F}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_SystemDevice"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SystemDevice:CIM_SystemComponent
{
		[Aggregate: ToSubclass, Description( "The parent system in the association."): 
		ToSubclass, DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, 
		Override( "GroupComponent"), PropertySources{ "GroupComponent"}: ToSubclass, 
		read: ToSubclass]
	CIM_System ref GroupComponent;
		[Description( "The logical device that is a component of a system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_LogicalDevice ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( " The CIM_ApplicationSystemSoftwareFeature associations identifies "
				"the  software features that make up a particular application system.  The "
				"software features can be part of different products. "): ToSubclass, DisplayName{ 
		"CIM_ApplicationSystemSoftwareFeature"}, Locale( 1033), UUID( "{0E17B9EA-E3D3-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_ApplicationSystemSoftwareFeature:CIM_SystemComponent
{
		[Aggregate: ToSubclass, Description( "The parent system in the association"): 
		ToSubclass, DisplayName{ "GroupComponent"}, Min( 0): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ApplicationSystem ref GroupComponent;
		[Description( "The child element that is a component of a system"): ToSubclass, 
		DisplayName{ "PartComponent"}, Min( 0): ToSubclass, Override( "PartComponent"), 
		PropertySources{ "PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_SoftwareFeature ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A link between the computer system and the operating system(s) "
				"installed or loaded on it. An operating system is 'installed' on a computer "
				"system, when placed on one of its storage extents - for example, copied to "
				"a disk drive or downloaded to memory. Using this definition, an operating "
				"system is 'installed' on a NetPC when downloaded via the network."): ToSubclass, 
		DisplayName{ "CIM_InstalledOS"}, dynamic: ToInstance, Locale( 1033), provider( 
		"MS_VIEW_INSTANCE_PROVIDER"), UUID( "{8502C575-5FBB-11D2-AAC1-006008C78BC7}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_InstalledOS"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_InstalledOS:CIM_SystemComponent
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "The operating system installed on the computer system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_OperatingSystem ref PartComponent;
		[Description( "Boolean indicating that the operating system is the default OS "
				"for the computer system."): ToSubclass, DisplayName{ "PrimaryOS"}, MappingStrings{ 
		"MIF.DMTF|Operating System|001.4"}: ToSubclass, PropertySources{ "PrimaryOS"}: 
		ToSubclass, read: ToSubclass]
	BOOLEAN PrimaryOS;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A link between the computer system and the file system(s) hosted "
				"on this computer system."): ToSubclass, DisplayName{ "CIM_HostedFileSystem"}, 
		Locale( 1033), UUID( "{A2EFC898-E3D3-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_HostedFileSystem:CIM_SystemComponent
{
		[Aggregate: ToSubclass, Description( "The computer system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_ComputerSystem ref GroupComponent;
		[Description( "The file system owned by the computer system."): ToSubclass, DisplayName{ 
		"PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_FileSystem ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A link between the file system and the logical file(s) addressed "
				"through this file system."): ToSubclass, DisplayName{ "CIM_FileStorage"}, 
		Locale( 1033), UUID( "{4A626026-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_FileStorage:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The file system."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_FileSystem ref GroupComponent;
		[Description( "The logical file stored in the context of the file system."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_LogicalFile ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A link between a process and the thread(s) running in the context "
				"of this process."): ToSubclass, DisplayName{ "CIM_ProcessThread"}, Locale( 
		1033), UUID( "{B7E6042C-DB36-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ProcessThread:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The process."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_Process ref GroupComponent;
		[Description( "The thread running in the context of the process."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_Thread ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_DirectoryContainsFile class represents an association between "
				"a directory and files contained within that directory."): ToSubclass, DisplayName{ 
		"CIM_DirectoryContainsFile"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		UUID( "{6F9D4740-8324-11d2-AAD9-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_DirectoryContainsFile"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_DirectoryContainsFile:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The directory."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_Directory ref GroupComponent;
		[Description( "The LogicalFile 'contained within' the Directory."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_DataFile ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( " The CIM_SoftwareFeatureSoftwareElements associations identifies "
				"the software elements that make up a particular software feature."): ToSubclass, 
		DisplayName{ "CIM_SoftwareFeatureSoftwareElements"}, dynamic: ToInstance, Locale( 
		1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), UUID( "{A91081E2-DB37-11d2-85FC-0000F8102E5F}"): 
		ToInstance, ViewSources{ "SELECT * FROM CIM_SoftwareFeatureSoftwareElements"}, 
		ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_SoftwareFeatureSoftwareElements:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The group component."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( FALSE): ToSubclass, Min( 0): ToSubclass, PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_SoftwareFeature ref GroupComponent;
		[Description( "The part component."): ToSubclass, DisplayName{ "PartComponent"}, 
		Max( FALSE): ToSubclass, Min( 1): ToSubclass, PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_SoftwareElement ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_Container association represents the relationship between "
				"a contained and a containing physical element. A containing object must be "
				"a physical package."): ToSubclass, DisplayName{ "CIM_Container"}, Locale( 
		1033), UUID( "{FAF76B6F-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_Container:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The physical package that contains other "
				"physical elements, including other packages."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref GroupComponent;
		[Description( "A free-form string representing the positioning of the PhysicalElement "
				"within the PhysicalPackage. Information relative to stationary elements in "
				"the Container (for example, 'second drive bay from the top'), angles, altitudes "
				"and other data may be recorded in this property. This string could supplement "
				"or be used in place of instantiating the CIM_Location object."): ToSubclass, 
		DisplayName{ "LocationWithinContainer"}, PropertySources{ "LocationWithinContainer"}: 
		ToSubclass, read: ToSubclass]
	STRING LocationWithinContainer;
		[Description( "The physical element which is contained in the package."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref PartComponent;
};
	[Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A component is typically contained by a physical package, such "
				"as a chassis or card. The CIM_PackagedComponent association makes this relationship "
				"explicit. In the first sentence, the word, 'typically', is used. This is "
				"because a component may be removed from, or not yet inserted into, its containing "
				"package (i.e., the Removable boolean property is TRUE). Therefore, a component "
				"may not always be associated with a container."): ToSubclass, DisplayName{ 
		"CIM_PackagedComponent"}, dynamic: ToInstance, Locale( 1033), provider( "MS_VIEW_INSTANCE_PROVIDER"), 
		UUID( "{FAF76B79-798C-11D2-AAD1-006008C78BC7}"): ToInstance, ViewSources{ "SELECT "
				"* FROM CIM_PackagedComponent"}, ViewSpaces{ "\\\\.\\root\\cimv2"}]
class CIM_PackagedComponent:CIM_Container
{
		[Aggregate: ToSubclass, Description( "The physical package that contains component(s)."): 
		ToSubclass, DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref GroupComponent;
		[Description( "The physical component which is contained in the package."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalComponent ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Racks, as simple enclosures, contain chassis that provide the physical "
				"components realizing processing nodes, storage devices, UPSs, etc. The CIM_ChassisInRack "
				"association makes explicit the 'containing' relationship between the rack "
				"and the chassis."): ToSubclass, DisplayName{ "CIM_ChassisInRack"}, Locale( 
		1033), UUID( "{FAF76B73-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ChassisInRack:CIM_Container
{
		[Description( "An integer indicating the lowest or 'bottom' U in which the chassis "
				"is mounted. A 'U' is a standard unit of measure for the height of a rack "
				"or rack-mountable component. It is equal to 1.75 inches or 4.445 cm."): ToSubclass, 
		DisplayName{ "BottomU"}, PropertySources{ "BottomU"}: ToSubclass, read: ToSubclass, 
		Units( "Us"): ToSubclass]
	UINT16 BottomU;
		[Aggregate: ToSubclass, Description( "The rack that contains the chassis."): ToSubclass, 
		DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_Rack ref GroupComponent;
		[Description( "The chassis which is mounted in the rack."): ToSubclass, DisplayName{ 
		"PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_Chassis ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Physical packages contain connectors as well as other physical "
				"elements. The CIM_ConnectorOnPackage association makes explicit the containment "
				"relationship between connectors and packages."): ToSubclass, DisplayName{ 
		"CIM_ConnectorOnPackage"}, Locale( 1033), UUID( "{FAF76B8C-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_ConnectorOnPackage:CIM_Container
{
		[Aggregate: ToSubclass, Description( "The physical package that has a connector."): 
		ToSubclass, DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref GroupComponent;
		[Description( "The physical connector."): ToSubclass, DisplayName{ "PartComponent"}, 
		Override( "PartComponent"), PropertySources{ "PartComponent"}: ToSubclass, read: 
		ToSubclass]
	CIM_PhysicalConnector ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Cards may be plugged into motherboards/baseboards, are daughtercards "
				"of an adapter, or support special card-like modules. These relationships "
				"are described by the CIM_CardOnCard association."): ToSubclass, DisplayName{ 
		"CIM_CardOnCard"}, Locale( 1033), UUID( "{FAF76B77-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_CardOnCard:CIM_Container
{
		[Aggregate: ToSubclass, Description( "The card that hosts another card."): ToSubclass, 
		DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_Card ref GroupComponent;
		[Description( "A string describing and identifying how the card is mounted on "
				"or plugged into the 'other' card. slot information could be included in this "
				"field and may be sufficient for certain management purposes. If so, this "
				"avoids creating instantiations of connector/slot objects just to model the "
				"relationship of cards to hosting boards or other adapters. On the other hand, "
				"if slot and connector information is available, this field could be used "
				"to provide more detailed mounting or slot insertion data."): ToSubclass, 
		DisplayName{ "MountOrSlotDescription"}, PropertySources{ "MountOrSlotDescription"}: 
		ToSubclass, read: ToSubclass]
	STRING MountOrSlotDescription;
		[Description( "The card that is plugged into or otherwise mounted on another card."): 
		ToSubclass, DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ 
		"PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_Card ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "A chassis can contain other packages, such as other chassis and "
				"cards. The CIM_PackageInChassis association makes explicit this relationship."): 
		ToSubclass, DisplayName{ "CIM_PackageInChassis"}, Locale( 1033), UUID( "{FAF76B74-798C-11D2-AAD1-006008C78BC7}"): 
		ToInstance]
class CIM_PackageInChassis:CIM_Container
{
		[Aggregate: ToSubclass, Description( "The chassis that contains other physical "
				"packages."): ToSubclass, DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, 
		Override( "GroupComponent"), PropertySources{ "GroupComponent"}: ToSubclass, 
		read: ToSubclass]
	CIM_Chassis ref GroupComponent;
		[Description( "The physical package which is contained in the chassis."): ToSubclass, 
		DisplayName{ "PartComponent"}, Override( "PartComponent"), PropertySources{ "PartComponent"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalPackage ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_CollectionOfSensors association indicates the binary sensors "
				"that make up the multi-state sensor."): ToSubclass, DisplayName{ "CIM_CollectionOfSensors"}, 
		Locale( 1033), UUID( "{A2ABF536-DB35-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_CollectionOfSensors:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The multi-state sensor."): ToSubclass, DisplayName{ 
		"GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), PropertySources{ 
		"GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_MultiStateSensor ref GroupComponent;
		[Description( "A binary sensor that is part of the multi-state sensor."): ToSubclass, 
		DisplayName{ "PartComponent"}, Min( 2): ToSubclass, Override( "PartComponent"), 
		PropertySources{ "PartComponent"}: ToSubclass, read: ToSubclass]
	CIM_BinarySensor ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Cables and links utilize physical connectors to actually 'connect' "
				"physical elements. This association explicitly defines this relationship "
				"of connectors for CIM_PhysicalLink."): ToSubclass, DisplayName{ "CIM_LinkHasConnector"}, 
		Locale( 1033), UUID( "{FAF76B8B-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_LinkHasConnector:CIM_Component
{
		[Aggregate: ToSubclass, Description( "The physical link that has a connector."): 
		ToSubclass, DisplayName{ "GroupComponent"}, Max( 1): ToSubclass, Override( "GroupComponent"), 
		PropertySources{ "GroupComponent"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalLink ref GroupComponent;
		[Description( "The physical connector."): ToSubclass, DisplayName{ "PartComponent"}, 
		Override( "PartComponent"), PropertySources{ "PartComponent"}: ToSubclass, read: 
		ToSubclass]
	CIM_PhysicalConnector ref PartComponent;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "This relationship associates Configuration objects with Setting "
				"objects. For example, a NetworkAdapter's Settings could change based on the "
				"site/network to which its hosting ComputerSystem is attached. In this case, "
				"the ComputerSystem would have two different Configuration objects, corresponding "
				"to the differences in network configuration for the two network segments. "
				"Configuration A would aggregate a Setting object for the NetworkAdapter when "
				"operating on segment \"ANet\", whereas Configuration B would aggregate a "
				"different NetworkAdapter Setting object, specific to segment \"BNet\". Note "
				"that many Settings of the computer are independent of the network Configuration. "
				"For example, both Configurations A and B would aggregate the same Setting "
				"object for the ComputerSystem's MonitorResolution."): ToSubclass, DisplayName{ 
		"CIM_SettingContext"}, Locale( 1033), UUID( "{F0B752E8-DB30-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_SettingContext
{
		[Aggregate: ToSubclass, Description( "The configuration object that aggregates "
				"the setting."): ToSubclass, DisplayName{ "Context"}, PropertySources{ "Context"}: 
		ToSubclass, read: ToSubclass]
	CIM_Configuration ref Context;
		[Description( "An aggregated setting."): ToSubclass, DisplayName{ "Setting"}, 
		PropertySources{ "Setting"}: ToSubclass, read: ToSubclass]
	CIM_Setting ref Setting;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_FromDirectorySpecification association identifies the source  directory "
				"for the file action. When this association is used,  the assumption is that "
				"the source directory already existed.  This association cannot exist with "
				"a  CIM_FromDirectoryAction association since a file action  can only involve "
				"single source directory."): ToSubclass, DisplayName{ "CIM_FromDirectorySpecification"}, 
		Locale( 1033), UUID( "{6715375E-DB2A-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_FromDirectorySpecification
{
		[Description( "The file name."): ToSubclass, DisplayName{ "FileName"}, Min( 0): 
		ToSubclass, PropertySources{ "FileName"}: ToSubclass, read: ToSubclass]
	CIM_FileAction ref FileName;
		[Description( "The source directory."): ToSubclass, DisplayName{ "SourceDirectory"}, 
		Max( 1): ToSubclass, Min( 0): ToSubclass, PropertySources{ "SourceDirectory"}: 
		ToSubclass, read: ToSubclass]
	CIM_DirectorySpecification ref SourceDirectory;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_FromDirectoryAction association identifies the source directory  for "
				"the file action. When this association is used, the assumption  is that the "
				"source directory was created by a previous action.  This association cannot "
				"exist with a CIM_FromDirectorySpecification  association since a file action "
				"can only  involve a single source directory. "): ToSubclass, DisplayName{ 
		"CIM_FromDirectoryAction"}, Locale( 1033), UUID( "{55D5B446-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_FromDirectoryAction
{
		[Description( "The file name."): ToSubclass, DisplayName{ "FileName"}, Min( 0): 
		ToSubclass, PropertySources{ "FileName"}: ToSubclass, read: ToSubclass]
	CIM_FileAction ref FileName;
		[Description( "The source directory."): ToSubclass, DisplayName{ "SourceDirectory"}, 
		Max( 1): ToSubclass, Min( 0): ToSubclass, PropertySources{ "SourceDirectory"}: 
		ToSubclass, read: ToSubclass]
	CIM_DirectoryAction ref SourceDirectory;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_AdjacentSlots "
				"describes the layout of slots on a hosting board or adapter card.  Information "
				"like the distance between the slots and whether they are 'shared' (if one "
				"is populated, then the other slot can not be used), is conveyed as properties "
				"of the association."): ToSubclass, DisplayName{ "CIM_AdjacentSlots"}, Locale( 
		1033), UUID( "{FAF76B88-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_AdjacentSlots
{
		[Description( "The distance, in inches, between adjacent slots."): ToSubclass, 
		DisplayName{ "DistanceBetweenSlots"}, PropertySources{ "DistanceBetweenSlots"}: 
		ToSubclass, read: ToSubclass, Units( "Inches"): ToSubclass]
	REAL32 DistanceBetweenSlots;
		[Description( "Slots can be located in close proximity on hostingboards or other "
				"cards, such that if one of these slots is populated by an adapter card, the "
				"other slot must be left empty. This relationship is indicated by the SharedSlots "
				"boolean set to TRUE."): ToSubclass, DisplayName{ "SharedSlots"}, PropertySources{ 
		"SharedSlots"}: ToSubclass, read: ToSubclass]
	BOOLEAN SharedSlots;
		[Description( "One of the adjacent slots."): ToSubclass, DisplayName{ "SlotA"}, 
		PropertySources{ "SlotA"}: ToSubclass, read: ToSubclass]
	CIM_Slot ref SlotA;
		[Description( "The 'other' adjacent slot."): ToSubclass, DisplayName{ "SlotB"}, 
		PropertySources{ "SlotB"}: ToSubclass, read: ToSubclass]
	CIM_Slot ref SlotB;
};
		[abstract, Association: ToInstance  ToSubclass, Description( "ElementSetting "
		"represents the association between ManagedSystemElements and the Setting "
		"class(es) defined for them."): ToSubclass, DisplayName{ "CIM_ElementSetting"}, 
		Locale( 1033), UUID("{8502C577-5FBB-11D2-AAC1-006008C78BC7}"): ToInstance]
class CIM_ElementSetting
{
		[Key: ToSubclass, Description( "The Element reference represents the role of the CIM_ManagedSystemElement "
				"object of the CIM_ElementSetting association. Role: The associated managed "
				"system element provides the element that implements the element setting."): 
		ToSubclass, DisplayName{ "Element"}, PropertySources{ "Element"}: ToSubclass, 
		read: ToSubclass]
	CIM_ManagedSystemElement ref Element;
		[Key: ToSubclass, Description( "The CIM_Setting reference represents the role of the CIM_Setting "
				"object of the CIM_ElementSetting association. Role: The associated setting "
				"provides the setting that implements the element setting."): ToSubclass, 
		DisplayName{ "Setting"}, PropertySources{ "Setting"}: ToSubclass, read: ToSubclass]
	CIM_Setting ref Setting;
};
		[Abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( " Since software elements in a ready to run state cannot transition "
		"into  another state, the value of the phase property is restricted to  in-state "
		"for CIM_SoftwareElement objects in a ready to run state. "): ToSubclass, 
		Locale( 1033), UUID( "{24783E8A-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_SoftwareElementChecks
{
		[Key: ToSubclass, Description( "The check."): ToSubclass, DisplayName{ "Check"}, Max( FALSE): ToSubclass, 
		Min( 0): ToSubclass, PropertySources{ "Check"}: ToSubclass, read: ToSubclass, 
		Weak: ToSubclass]
	CIM_Check ref Check;
		[Key: ToSubclass, Aggregate: ToSubclass, Description( "The element."): ToSubclass, DisplayName{ 
		"Element"}, Max( 1): ToSubclass, Min( 1): ToSubclass, PropertySources{ "Element"}: 
		ToSubclass, read: ToSubclass]
	CIM_SoftwareElement ref Element;
		[Description( " The Phase property indicates whether the referenced check is an "
				" in-state check or a next-state check."): ToSubclass, DisplayName{ "Phase"}, 
		PropertySources{ "Phase"}: ToSubclass, read: ToSubclass, Values{ "In-State", 
		"Next-State"}: ToSubclass]
	UINT16 Phase;
};
	[abstract, Association: ToInstance  ToSubclass, Description( " "
				"The CIM_DirectorySpecificationFile association identifies the   directorythat "
				"contains the file being specified by referencing  the CIM_DirectorySpecification "
				"class. "): ToSubclass, DisplayName{ "CIM_DirectorySpecificationFile"}, Locale( 
		1033), UUID( "{BCD64CCE-DB29-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_DirectorySpecificationFile
{
		[Description( "The directory specification."): ToSubclass, DisplayName{ "DirectorySpecification"}, 
		Max( 1): ToSubclass, Min( 0): ToSubclass, PropertySources{ "DirectorySpecification"}: 
		ToSubclass, read: ToSubclass]
	CIM_DirectorySpecification ref DirectorySpecification;
		[Description( "The file specification."): ToSubclass, DisplayName{ "FileSpecification"}, 
		Min( 0): ToSubclass, PropertySources{ "FileSpecification"}: ToSubclass, read: 
		ToSubclass]
	CIM_FileSpecification ref FileSpecification;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ToDirectoryAction association identifies the target directory for  the "
				"file action. When this association is used, the assumption  is that the target "
				"directory was created by a previous action.   This association cannot exist "
				"with a CIM_ToDirectorySpecification  association since a file action can "
				"only  involve a single target directory. "): ToSubclass, DisplayName{ "CIM_ToDirectoryAction"}, 
		Locale( 1033), UUID( "{B58D172E-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ToDirectoryAction
{
		[Description( "The destination directory."): ToSubclass, DisplayName{ "DestinationDirectory"}, 
		Max( 1): ToSubclass, Min( 0): ToSubclass, PropertySources{ "DestinationDirectory"}: 
		ToSubclass, read: ToSubclass]
	CIM_DirectoryAction ref DestinationDirectory;
		[Description( "The name of the file."): ToSubclass, DisplayName{ "FileName"}, 
		Min( 0): ToSubclass, PropertySources{ "FileName"}: ToSubclass, read: ToSubclass]
	CIM_CopyFileAction ref FileName;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "This relationship associates a CIM_Dependency with one or more "
				"CIM_Configuration objects. For example, a computer system's dependencies "
				"could change based on the site/network to which the system is attached."): 
		ToSubclass, DisplayName{ "CIM_DependencyContext"}, Locale( 1033), UUID( "{A228E208-DB22-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_DependencyContext
{
		[Aggregate: ToSubclass, Description( "The configuration object that aggregates "
				"the dependency."): ToSubclass, DisplayName{ "Context"}, PropertySources{ 
		"Context"}: ToSubclass, read: ToSubclass]
	CIM_Configuration ref Context;
		[Description( "An aggregated dependency."): ToSubclass, DisplayName{ "Dependency"}, 
		PropertySources{ "Dependency"}: ToSubclass, read: ToSubclass]
	CIM_Dependency ref Dependency;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Indicates the physical elements that make up a product."): ToSubclass, 
		DisplayName{ "CIM_ProductPhysicalElements"}, Locale( 1033), UUID( "{502F00A0-DB2B-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ProductPhysicalElements
{
		[Description( "The physical element which is a part of the product."): ToSubclass, 
		DisplayName{ "Component"}, PropertySources{ "Component"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref Component;
		[Aggregate: ToSubclass, Description( "The product."): ToSubclass, DisplayName{ 
		"Product"}, Max( 1): ToSubclass, PropertySources{ "Product"}: ToSubclass, read: 
		ToSubclass]
	CIM_Product ref Product;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ProductFRU "
				"is an association between product and FRU that provides information regarding "
				"what product components have been or are being replaced.  The association "
				"is one to many, conveying that a product can have many FRUs, and that a particular "
				"instance of a FRU is only applied to one (instance of a) product."): ToSubclass, 
		DisplayName{ "CIM_ProductFRU"}, Locale( 1033), UUID( "{EB98A1B2-DB36-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ProductFRU
{
		[Description( "The FRU."): ToSubclass, DisplayName{ "FRU"}, PropertySources{ "FRU"}: 
		ToSubclass, read: ToSubclass]
	CIM_FRU ref FRU;
		[Description( "The product to which the FRU is applied."): ToSubclass, DisplayName{ 
		"Product"}, Max( 1): ToSubclass, PropertySources{ "Product"}: ToSubclass, read: 
		ToSubclass]
	CIM_Product ref Product;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_Statistics "
				"is an association that relates managed system elements to the statistical "
				"group(s) that apply to them."): ToSubclass, DisplayName{ "CIM_Statistics"}, 
		Locale( 1033), UUID( "{956597A3-7D80-11D2-AAD3-006008C78BC7}"): ToInstance]
class CIM_Statistics
{
		[Description( "The CIM_ManagedSystemElement for which statistical or metric data "
				"is defined."): ToSubclass, DisplayName{ "Element"}, PropertySources{ "Element"}: 
		ToSubclass, read: ToSubclass]
	CIM_ManagedElement ref Element;
		[Description( "The statistical information/object."): ToSubclass, DisplayName{ 
		"Stats"}, PropertySources{ "Stats"}: ToSubclass, read: ToSubclass]
	CIM_StatisticalInformation ref Stats;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_ErrorCountersForDevice "
				"relates the CIM_DeviceErrorCounts class to the logical device to which it "
				"applies. "): ToSubclass, DisplayName{ "CIM_ErrorCountersForDevice"}, Locale( 
		1033), UUID( "{2D79F3A0-D025-11d2-85F5-0000F8102E5F}"): ToInstance]
class CIM_ErrorCountersForDevice:CIM_Statistics
{
		[Description( "The device to which the error counters apply. "): ToSubclass, DisplayName{ 
		"Element"}, Max( 1): ToSubclass, Min( 1): ToSubclass, Override( "Element"), PropertySources{ 
		"Element"}: ToSubclass, read: ToSubclass]
	CIM_LogicalDevice ref Element;
		[Description( "The statistical object - in this case, the error counter class. "
				""): ToSubclass, DisplayName{ "Stats"}, Override( "Stats"), PropertySources{ 
		"Stats"}: ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_DeviceErrorCounts ref Stats;
};
		[Abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "CIM_CollectedMSEs is a generic association used to establish the "
		"members of the grouping object, CollectionOfMSEs."): ToSubclass, Locale( 1033)]
class CIM_CollectedMSEs
{
		[Aggregate: ToSubclass, Description( "The grouping or 'bag' object that represents "
				"the Collection."): ToSubclass, DisplayName{ "Collection"}, key: DisableOverride 
		 ToInstance  ToSubclass, PropertySources{ "Collection"}: ToSubclass]
	CIM_CollectionOfMSEs ref Collection;
		[Description( "The members of the Collection."): ToSubclass, DisplayName{ "Member"}, 
		key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "Member"}: ToSubclass]
	CIM_ManagedSystemElement ref Member;
};
		[Abstract, Association: ToInstance  ToSubclass, Description( "CollectionSetting "
		"represents the association between a CollectionOfMSEs class and the Setting "
		"class(es) defined for them."): ToSubclass, Locale( 1033)]
class CIM_CollectionSetting
{
		[Description( "The CollectionOfMSEs."): ToSubclass, DisplayName{ "Collection"}, 
		key: DisableOverride  ToInstance  ToSubclass, PropertySources{ "Collection"}: 
		ToSubclass]
	CIM_CollectionOfMSEs ref Collection;
		[Description( "The Setting object associated with the Collection."): ToSubclass, 
		DisplayName{ "Setting"}, key: DisableOverride  ToInstance  ToSubclass, PropertySources{ 
		"Setting"}: ToSubclass]
	CIM_Setting ref Setting;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "CIM_ParticipatesInSet indicates which physical elements should "
				"be replaced together."): ToSubclass, DisplayName{ "CIM_ParticipatesInSet"}, 
		Locale( 1033), UUID( "{FAF76B6D-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_ParticipatesInSet
{
		[Description( "The physical element which should be replaced with other elements, "
				"as a set."): ToSubclass, DisplayName{ "Element"}, PropertySources{ "Element"}: 
		ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref Element;
		[Aggregate: ToSubclass, Description( "The CIM_ReplacementSet."): ToSubclass, DisplayName{ 
		"Set"}, PropertySources{ "Set"}: ToSubclass, read: ToSubclass]
	CIM_ReplacementSet ref Set;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_CompatibleProduct "
				"is an association between products that can indicate a wide variety of information. "
				"For example, it can indicate that the two referenced products interoperate, "
				"that they can be installed together, that one can be the physical container "
				"for the other, etc. The string property, CompatibilityDescription, defines "
				"how the products interoperate or are compatible, any limitations regarding "
				"interoperability or installation, ..."): ToSubclass, DisplayName{ "CIM_CompatibleProduct"}, 
		Locale( 1033), UUID( "{2F648FBA-DB22-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_CompatibleProduct
{
		[Description( "CompatibilityDescription is a free-form string defining how the "
				"two referenced products interoperate or are compatible, any limitations to "
				"compatibility, etc."): ToSubclass, DisplayName{ "CompatibilityDescription"}, 
		PropertySources{ "CompatibilityDescription"}: ToSubclass, read: ToSubclass]
	STRING CompatibilityDescription;
		[Description( "The compatible product."): ToSubclass, DisplayName{ "CompatibleProduct"}, 
		PropertySources{ "CompatibleProduct"}: ToSubclass, read: ToSubclass]
	CIM_Product ref CompatibleProduct;
		[Description( "The product for which compatible offerings are defined."): ToSubclass, 
		DisplayName{ "Product"}, PropertySources{ "Product"}: ToSubclass, read: ToSubclass]
	CIM_Product ref Product;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "The CIM_StorageDefect aggregation collects the storage errors for "
				"a storage extent."): ToSubclass, DisplayName{ "CIM_StorageDefect"}, Locale( 
		1033), UUID( "{5CC70817-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_StorageDefect
{
		[Description( "CIM_StorageError references the Error object, defining the starting "
				"and ending addresses that are 'mapped out' of the storage extent."): ToSubclass, 
		DisplayName{ "Error"}, PropertySources{ "Error"}: ToSubclass, read: ToSubclass, 
		Weak: ToSubclass]
	CIM_StorageError ref Error;
		[Aggregate: ToSubclass, Description( "The Extent reference defines the storage "
				"extent on which the errors occurred."): ToSubclass, DisplayName{ "Extent"}, 
		Max( 1): ToSubclass, Min( 1): ToSubclass, PropertySources{ "Extent"}: ToSubclass, 
		read: ToSubclass]
	CIM_StorageExtent ref Extent;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "An "
				"association between a LocalFileSystem and its Directories indicating that "
				"the specified Directories are available for mount. When exporting an entire "
				"FileSystem, the Directory should reference the topmost directory of the FileSystem."): 
		ToSubclass, DisplayName{ "CIM_Export"}, Locale( 1033), UUID( "{75BCF4F8-DB46-11D2-B4C8-80080C7B6371}"): 
		ToInstance]
class CIM_Export
{
		[Description( "The directory exported for NFS mount."): ToSubclass, DisplayName{ 
		"Directory"}, PropertySources{ "Directory"}: ToSubclass, read: ToSubclass]
	CIM_Directory ref Directory;
		[Description( "Name under which the directory is exported."): ToSubclass, DisplayName{ 
		"ExportedDirectoryName"}, PropertySources{ "ExportedDirectoryName"}: ToSubclass, 
		read: ToSubclass]
	STRING ExportedDirectoryName;
		[Description( "The local file system."): ToSubclass, DisplayName{ "LocalFS"}, 
		Max( 1): ToSubclass, PropertySources{ "LocalFS"}: ToSubclass, read: ToSubclass]
	CIM_LocalFileSystem ref LocalFS;
};
		[Abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( " The CIM_ProductSoftwareFeatures association identifies the software "
		"features for a particular product. "): ToSubclass, Locale( 1033), 
		UUID("{7C39D12A-DB2B-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ProductSoftwareFeatures
{
		[Key: ToSubclass, Description( "The component."): ToSubclass, DisplayName{ "Component"}, Max( FALSE): 
		ToSubclass, Min( 1): ToSubclass, PropertySources{ "Component"}: ToSubclass, read: 
		ToSubclass, Weak: ToSubclass]
	CIM_SoftwareFeature ref Component;
		[Key: ToSubclass, Aggregate: ToSubclass, Description( "The product."): ToSubclass, DisplayName{ 
		"Product"}, Max( FALSE): ToSubclass, Min( 0): ToSubclass, PropertySources{ "Product"}: 
		ToSubclass, read: ToSubclass]
	CIM_Product ref Product;
};
	[abstract, Association: ToInstance  ToSubclass, Description( " "
				"The CIM_ActionSequence association is used to define a series of  operations "
				"that either transitions the software element, referenced  by the CIM_SoftwareElementActions "
				"association, to its next state or  removes the software element from its "
				"current environment. The CIM_Action classes participating in this association "
				"must have the same value for the Direction property since they are either "
				"part of a sequence to  transition a software element into its next state "
				"or to uninstall a  software element. The next-state actions and uninstall "
				"actions  associated with a particular software element must be a continuous "
				" sequence. Since the CIM_ActionSequence is an association the loops on  the "
				"CIM_Action class with roles for the 'prior' action and 'next' action in a "
				"sequence, the need for a continuous sequence implies:  (1)Within the set "
				"of next-state or uninstall actions, there is one and only one action that "
				"does not have an instance of the CIM_ActionSequence  association referencing "
				"it in the 'next' role. This is the first action in the sequence. (2) Within "
				"the set of next-state or uninstall actions, there is one and only one action "
				"that does not have an instance of the CIM_ActionSequence association referencing "
				"it in the \"prior\" role. This  is the last action in the sequence. (3) All "
				"other actions within the  set of next-state and uninstall actions must participate "
				"in two  instances of the CIM_ActionSequence association, one in a  prior "
				"role and one in the next role."): ToSubclass, DisplayName{ "CIM_ActionSequence"}, 
		Locale( 1033), UUID( "{F127E50E-E3E0-11d2-8601-0000F8102E5F}"): ToInstance]
class CIM_ActionSequence
{
		[Description( "The next action."): ToSubclass, DisplayName{ "Next"}, Max( 1): 
		ToSubclass, Min( 0): ToSubclass, PropertySources{ "Next"}: ToSubclass, read: 
		ToSubclass]
	CIM_Action ref Next;
		[Description( "The prior action."): ToSubclass, DisplayName{ "Prior"}, Max( 1): 
		ToSubclass, Min( 0): ToSubclass, PropertySources{ "Prior"}: ToSubclass, read: 
		ToSubclass]
	CIM_Action ref Prior;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "This "
				"association relates a CIM_Configuration object to one or more managed system "
				"elements. The CIM_Configuration object represents a certain behavior, or "
				"a desired functional state for the associated CIM_ManagedSystemElement."): 
		ToSubclass, DisplayName{ "CIM_ElementConfiguration"}, Locale( 1033), UUID( "{FC049DCE-DB29-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ElementConfiguration
{
		[Description( "The CIM_Configuration object that groups the settings and dependencies "
				"associated with the managed system element."): ToSubclass, DisplayName{ "Configuration"}, 
		PropertySources{ "Configuration"}: ToSubclass, read: ToSubclass]
	CIM_Configuration ref Configuration;
		[Description( "The managed system element."): ToSubclass, DisplayName{ "Element"}, 
		PropertySources{ "Element"}: ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref Element;
};
		[Abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( " This association is used to identify the actions for a software "
		"element. "): ToSubclass, Locale( 1033), UUID( "{4B82D255-E3CD-11d2-8601-0000F8102E5F}"): 
		ToInstance]
class CIM_SoftwareElementActions
{
		[Key: ToSubclass, DisplayName{ "Action"}, Max( FALSE): ToSubclass, Min( 0): ToSubclass, PropertySources{ 
		"Action"}: ToSubclass, read: ToSubclass, Weak: ToSubclass]
	CIM_Action ref Action;
		[Key: ToSubclass, Aggregate: ToSubclass, DisplayName{ "Element"}, Max( 1): ToSubclass, Min( 1): 
		ToSubclass, PropertySources{ "Element"}: ToSubclass, read: ToSubclass]
	CIM_SoftwareElement ref Element;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ToDirectorySpecification association identifies the target  directory "
				"for the file action. When this association is used,  the assumption is that "
				"the target directory already existed.   This association cannot exist with "
				"a CIM_ToDirectoryAction association since a file action can only involve "
				"a  single target directory."): ToSubclass, DisplayName{ "CIM_ToDirectorySpecification"}, 
		Locale( 1033), UUID( "{C3E25A3C-DB31-11d2-85FC-0000F8102E5F}"): ToInstance]
class CIM_ToDirectorySpecification
{
		[Description( "The destination directory."): ToSubclass, DisplayName{ "DestinationDirectory"}, 
		Max( 1): ToSubclass, Min( 0): ToSubclass, PropertySources{ "DestinationDirectory"}: 
		ToSubclass, read: ToSubclass]
	CIM_DirectorySpecification ref DestinationDirectory;
		[Description( "The file name."): ToSubclass, DisplayName{ "FileName"}, Min( 0): 
		ToSubclass, PropertySources{ "FileName"}: ToSubclass, read: ToSubclass]
	CIM_CopyFileAction ref FileName;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "The "
				"CIM_ActsAsSpare association indicates which elements can spare or replace "
				"the other aggregated elements.  The fact that a spare can operate in \"hot "
				"standby\" mode is specified on an element by element basis."): ToSubclass, 
		DisplayName{ "CIM_ActsAsSpare"}, Locale( 1033), UUID( "{64C1726E-DB21-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_ActsAsSpare
{
		[Description( "The Group reference represents the CIM_SpareGroup."): ToSubclass, 
		DisplayName{ "Group"}, PropertySources{ "Group"}: ToSubclass, read: ToSubclass]
	CIM_SpareGroup ref Group;
		[Description( "HotStandby property is a boolean indicating that the spare is operating "
				"as a hot standby."): ToSubclass, DisplayName{ "HotStandby"}, PropertySources{ 
		"HotStandby"}: ToSubclass, read: ToSubclass]
	BOOLEAN HotStandby;
		[Description( "A managed system element acting as a spare and participating in "
				"the spare group."): ToSubclass, DisplayName{ "Spare"}, PropertySources{ "Spare"}: 
		ToSubclass, read: ToSubclass]
	CIM_ManagedSystemElement ref Spare;
};
	[abstract, Aggregation: ToSubclass, Association: ToInstance  ToSubclass, 
		Description( "Indicates that a FRU may be composed of other product(s)."): ToSubclass, 
		DisplayName{ "CIM_FRUIncludesProduct"}, Locale( 1033), UUID( "{87FEEDCA-DB2A-11d2-85FC-0000F8102E5F}"): 
		ToInstance]
class CIM_FRUIncludesProduct
{
		[Description( "The product which is a part of the FRU."): ToSubclass, DisplayName{ 
		"Component"}, PropertySources{ "Component"}: ToSubclass, read: ToSubclass]
	CIM_Product ref Component;
		[Aggregate: ToSubclass, Description( "The FRU."): ToSubclass, DisplayName{ "FRU"}, 
		Max( 1): ToSubclass, PropertySources{ "FRU"}: ToSubclass, read: ToSubclass]
	CIM_FRU ref FRU;
};
	[abstract, Association: ToInstance  ToSubclass, Description( "CIM_PhysicalElementLocation "
				"associates a physical element with a CIM_Location object for inventory or "
				"replacement purposes."): ToSubclass, DisplayName{ "CIM_PhysicalElementLocation"}, 
		Locale( 1033), UUID( "{FAF76B68-798C-11D2-AAD1-006008C78BC7}"): ToInstance]
class CIM_PhysicalElementLocation
{
		[Description( "The physical element whose location is specified."): ToSubclass, 
		DisplayName{ "Element"}, PropertySources{ "Element"}: ToSubclass, read: ToSubclass]
	CIM_PhysicalElement ref Element;
		[Description( "The physical element's location."): ToSubclass, DisplayName{ "PhysicalLocation"}, 
		Max( 1): ToSubclass, PropertySources{ "PhysicalLocation"}: ToSubclass, read: 
		ToSubclass]
	CIM_Location ref PhysicalLocation;
};