windows-xp/Source/XPSP1/NT/base/published/wmicore.mof

/*++

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    wmicore.mof

Abstract:

    This file defines all of the MOF classes "built in" to WMI. Typically
    this will be for all data providers that are shipped by MS. The list
    includes:

        WMI specific internal classes
        Power Management
        NDIS
        SMBIOS Data
        Keyboard
        Mouse
        Disk
        IDE
        Serial
        Temperature via ACPI

Revision History:

--*/

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

#pragma classflags("forceupdate")

//
// Wmi internal classes


class WMIEvent : __ExtrinsicEvent
{
};



[abstract]
class MS_WmiInternal
{
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This class supplies the binary mof information") : amended,
 guid("{05901221-D566-11d1-B2F0-00A0C9062910}")
]
class MSWmi_MofData : MS_WmiInternal
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read
    ] uint32 Unused1;

    [WmiDataId(2),
     read
    ] uint32 Unused2;



    [WmiDataId(3),
     read
    ] uint32 Size;

    [WmiDataId(4),
     read
   ] uint32 Unused4;


    [WmiDataId(5),
     WmiSizeIs("Size"),
     read
    ] uint8 BinaryMofData[];
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This class supplies additional information about a data provider. Querying this class with an instance name returned from another class query will return additional information about the instance") : amended,
 guid("{C7BF35D0-AADB-11d1-BF4A-00A0C9062910}")
]
class MSWmi_ProviderInfo : MS_WmiInternal
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    // CM_DRP_FRIENDLY_NAME
    [WmiDataId(1),
     read,
     DisplayName("Friendly Name") : amended
    ] string FriendlyName;

    // CM_DRP_DEVICEDESC
    [WmiDataId(2),
     read,
     DisplayName("Description") : amended
    ] string Description;

    // CM_DRP_LOCATION_INFORMATION
    [WmiDataId(3),
     read,
     DisplayName("Location") : amended
    ] string Location;

    // CM_DRP_MFG
    [WmiDataId(4),
     read,
     DisplayName("Manufacturer") : amended
    ] string Manufacturer;

    // CM_DRP_SERVICE
    [WmiDataId(5),
     read,
     DisplayName("Service") : amended
    ] string Service;

    // CONSIDER: adding device capabilities
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This class supplies the PnPDeviceId for a specific device") : amended,
 guid("{C7BF35D2-AADB-11d1-BF4A-00A0C9062910}"),
 GuidName1("DATA_PROVIDER_PNPID_GUID")
 ]
class MSWmi_PnPDeviceId : MS_WmiInternal
{
//
// Note to driver developers:
//
//    Support for this guid is required if properties in the wmi namespace
//    are to be mapped into another namespace via the view provider. 
//
//    This guid is automatically supported by WMI if the following conditions
//    are met:
//
//    1. The device registers with PDO instance names for all guids
//       (ie, WMIREG_FLAG_PDO_INSTANCE_NAMES)
//
//    If the driver cannot follow the rules above and WMI cannot support 
//    the guid automatically, then the driver can support it in its own
//    driver code. 


    [key, read]
     string InstanceName;
    [read] boolean Active;

    // Pnp device id
    [WmiDataId(1),
     Description("PnP Device Id for the device. This property is useful for mapping from the wmi namespace to the cimv2 namespace classes using the view provider") : amended,
     read,
     DisplayName("PnP Device Id") : amended
    ] string PnPDeviceId;
};


[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This class supplies the Instance names associated with a PnP Device Instance Id") : amended,
 guid("{C7BF35D3-AADB-11d1-BF4A-00A0C9062910}"),
 GuidName1("DATA_PROVIDER_PNPID_INSTANCE_NAMES_GUID")
 ]
class MSWmi_PnPInstanceNames : MS_WmiInternal
{
//
// Note to driver developers:
//
//    Support for this guid is required if properties in the wmi namespace
//    are to be mapped into another namespace via the view provider. 
//
//    This guid is automatically supported by WMI if the following conditions
//    are met:
//
//    1. The device registers with PDO instance names for all guids
//       (ie, WMIREG_FLAG_PDO_INSTANCE_NAMES)
//
//    If the driver cannot follow the rules above and WMI cannot support 
//    the guid automatically, then the driver can support it in its own
//    driver code. 


    [key, read]
     string InstanceName;
    [read] boolean Active;

    // Pnp device id
    [WmiDataId(1),
     Description("Count of instance names associated with this PnPId") : amended,
     read,
     DisplayName("Count") : amended
    ] uint32 Count;

    // Instance names
    [WmiDataId(2),
     WmiSizeIs("Count"),
     Description("Wmi Instance Names for the device. This property is useful for mapping from the wmi namespace to the cimv2 namespace classes using the view provider") : amended,
     read,
     DisplayName("Instance Name List") : amended
    ] string InstanceNameList[];
};

[WMI,
 guid("{F8C60AED-EF8D-4f95-9EA8-F04318A00F30}")
]
class MSWmi_Guid
{
    [WmiDataId(1)]
    uint8 Guid[16];
};

[Dynamic, Provider("WMIProv"),
 WMI,
 guid("{B48D49A1-E777-11d0-A50C-00A0C9062910}"),
 description("This event reports whenever a guid is registered or unregistered") : amended
]
class MSWmi_GuidRegistrationInfo : WMIEvent
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("Type of operation") : amended,
     Values{"Registration Add", "Registration Remove", "Registration Update"} : amended,
     ValueMap{"1",              "2",                   "4"}
    ]
    uint32 Operation;

    [WmiDataId(2),
     Description("Count of guids being registered, unregistered, or updated") : amended
    ]
    uint32 GuidCount;

    [WmiDataId(3),
     WmiSizeIs("GuidCount"),
     Description("List of guids") : amended
    ]
    MSWmi_Guid GuidList[];
};


//
// ACPI info classes
//
[Dynamic, Provider("WMIProv"),
 WMI,
 Description("ACPI Table data") : amended,
 guid("{5DAF38AE-F6F8-4d90-8199-EBDE6800EC3B}")
]
class MSAcpiInfo
{
    [key, read]
     string InstanceName;
    [read] boolean Active;


    [WmiDataId(1),
     Description("Boot Architecture") : amended,
     Values{"LEGACY_DEVICES", "I8042" } : amended,
     ValueMap{"1", "2"}
    ]
    uint32 BootArchitecture;

    [WmiDataId(2),
     Description("Systems Preferred Power Profile") : amended
    ]
    uint32 PreferredProfile;

    [WmiDataId(3),
     BitValues{"this one bit flag indicates whether or not the WBINVD instruction works properly,if this bit is not set we can not use S2, S3 states, or C3 on MP machines",
            "this flag indicates if wbinvd works EXCEPT that it does not invalidate the cache",
            "this flag indicates that the C1 state is supported on all processors.",
            "this one bit flag indicates whether support for the C2 state is restricted to uniprocessor machines",
            "this bit indicates whether the PWR button is treated as a fix feature (0) or a generic feature (1)",
            "SLEEP_BUTTON_GENERIC",
            "this bit indicates whether the RTC wakeup status is reported in fix register space (0) or not (1)",
            "RTC_WAKE_FROM_S4",
            "This bit indicates whether the machine implements a 24 or 32 bit timer.",
            "This bit indicates whether the machine supports docking",
            "This bit indicates whether the machine supports reset",
            "This bit indicates whether the machine case can be opened",
            "This bit indicates whether the machine has no video"
           } : amended,
     BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"},
     Description("Capabilities") : amended
    ]
    uint32 Capabilities;
};

//
// SMBIOS data classes
//
[abstract]
class MS_SmBios
{
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Raw SMBIOS Tables") : amended,
 guid("{8F680850-A584-11d1-BF38-00A0C9062910}")
]
class MSSmBios_RawSMBiosTables : MS_SmBios
{
    [key, read]
     string InstanceName;

    [read] boolean Active;

    [WmiDataId(1),
     read,
     DisplayName("Used 20 Calling Method") : amended
    ] boolean Used20CallingMethod;

    [WmiDataId(2),
     read,
     DisplayName("Smbios Major Version") : amended
    ] uint8 SmbiosMajorVersion;

    [WmiDataId(3),
     read,
     DisplayName("Smbios Minor Version") : amended
    ] uint8 SmbiosMinorVersion;

    [WmiDataId(4),
     read,
     DisplayName("Dmi Revision") : amended
    ] uint8 DmiRevision;


    [WmiDataId(5),
     read,
     DisplayName("Size") : amended
    ] uint32 Size;

    [WmiDataId(6),
     WmiSizeIs("Size"),
     read,
     DisplayName("SMBios Data") : amended
    ] uint8 SMBiosData[];

};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Raw SMBIOS Eventlog") : amended,
 guid("{8F680851-A584-11d1-BF38-00A0C9062910}")
]
class MSSmBios_SMBiosEventlog : MS_SmBios
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read
    ] uint16 LogTypeDescLength;

    [WmiDataId(2),
     read
    ] boolean LogHeaderDescExists;

    [WmiDataId(3),
     read
    ] uint8 Reserved;

    [WmiDataId(4),
     read
    ] uint16 LogAreaLength;

    [WmiDataId(5),
     read
    ] uint16 LogHeaderStart;

    [WmiDataId(6),
     read
    ] uint16 LogDataStart;

    [WmiDataId(7),
     read
    ] uint8 AccessMethod;


    [WmiDataId(8),
     read
    ] uint8 LogStatus;


    [WmiDataId(9),
     read
    ] uint32 LogChangeToken;

    [WmiDataId(10),
     read
    ] uint32 AccessMethodAddress;

    //
    // LogHeaderFormat, NumberLogTypeDesc, LengthEachLogTypeDesc and
    // ListLogTypeDesc are only valid if LogHeaderDescExists is TRUE.
    // This means that SMBIOS is revision 2.1
    //
    [WmiDataId(11),
     read
    ] uint8 LogHeaderFormat;

    [WmiDataId(12),
     read
    ] uint8 NumberLogTypeDesc;

    [WmiDataId(13),
     read
    ] uint8 LengthEachLogTypeDesc;

    [WmiDataId(14),
     WmiSizeIs("LogTypeDescLength"),
     read
    ] uint8 ListLogTypeDesc[];

    [WmiDataId(15),
     WmiSizeIs("LogAreaLength"),
     read
    ] uint8 LogArea[];

};

[WMI,
 guid("{8F680852-A584-11d1-BF38-00A0C9062910}"),
 Description("SYSID UUID") : amended,
 HeaderName("SYSID_UUID")
]
class MSSmBios_SysidUUID : MS_SmBios
{
    [WmiDataId(1)]
    uint8 Uuid[16];
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("List of UUID SYSIDS") : amended,
 guid("{8F680853-A584-11d1-BF38-00A0C9062910}"),
 GuidName1("SYSID_UUID_DATA_GUID")
]
class MSSmBios_SysidUUIDList : MS_SmBios
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read
    ] uint32 Count;

    [WmiDataId(2),
     WmiSizeIs("Count"),
     read
    ] MSSmBios_SysidUUID List;

};

[WMI,
 guid("{8F680854-A584-11d1-BF38-00A0C9062910}"),
 Description("SYSID 1394") : amended,
 HeaderName("SYSID_1394")
]
class MSSmBios_Sysid1394 : MS_SmBios
{
    [WmiDataId(1)
    ]
    uint8 x1394[8];
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("List of 1394 SYSIDS") : amended,
 guid("{8F680855-A584-11d1-BF38-00A0C9062910}"),
 GuidName1("SYSID_1394_DATA_GUID")
]
class MSSmBios_Sysid1394List : MS_SmBios
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read
    ] uint32 Count;

    [WmiDataId(2),
     WmiSizeIs("Count"),
     read
    ] MSSmBios_Sysid1394 List;

};

[abstract]
class MSMCAInfo
{
};


//
// NOTE: For all MCA events the first four data items must be identical and
//       match whay is in MSMCAEvent_Header.
//
[WMI,
 guid("{6381C27F-C8FA-4da7-8953-B86833736E15}")
]
class MSMCAEvent_Header
{
    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{5CE27CDE-D179-4c68-937F-A07B8CC2EA39}"),
 Description("MCA CPU Error Event") : amended
]
class MSMCAEvent_CPUError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Cache or TLB level of error") : amended
    ]
    uint32 Level;

    [WmiDataId(7),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(8),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
    
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{433EEA38-C1A7-48f1-884F-B6875F176CC7}"),
 Description("MCA Memory Error Event") : amended
]
class MSMCAEvent_MemoryError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0", "1", "2", "3", "4", "5", "6", "7",
               "8", "9", "10", "11", "12", "13", "14", "15", "16"},
     BitValues{"MEM_ERROR_STATUS is valid",
            "MEM_PHYSICAL_ADDR is valid",
            "MEM_ADDR_MASK is valid",
            "MEM_NODE is valid",
            "MEM_CARD is valid",
            "MEM_MODULE is valid",
            "MEM_BANK is valid",
            "MEM_DEVICE is valid",
            "MEM_ROW is valid",
            "MEM_COLUMN is valid",
            "MEM_BIT_POSITION is valid",
            "MEM_PLATFORM_REQUESTOR_ID is valid",
            "MEM_PLATFORM_RESPONDER_ID is valid",
            "MEM_PLATFORM_TARGET is valid",
            "MEM_PLATFORM_BUS_SPECIFIC_DATA is valid",
            "MEM_PLATFORM_OEM_ID is valid",
            "MEM_PLATFORM_OEM_DATA_STRUCT is valid"} : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Memory Error Status") : amended
    ]
    uint64 MEM_ERROR_STATUS;

    [WmiDataId(8),
     Description("64bit physical address of the memory error") : amended
    ]
    uint64 MEM_PHYSICAL_ADDR;

    [WmiDataId(9),
     Description("Defines the valid address bits in the 64-Bit physical address of the memory error. The mask specifies the granularity of the physical address which is dependent on the hardware implementation factors such as interleaving.") : amended
    ]
    uint64 MEM_PHYSICAL_MASK;

    [WmiDataId(10),
     Description("Hardware address of the responder to the transaction") : amended
    ]
    uint64 RESPONDER_ID;

    [WmiDataId(11),
     Description("Hardware address of intended target of transaction") : amended
    ]
    uint64 TARGET_ID;

    [WmiDataId(12),
     Description("Hardware address of the device or component initiating transaction") : amended
    ]
    uint64 REQUESTOR_ID;

    [WmiDataId(13),
     Description("OEM specific bus dependent data") : amended
    ]
    uint64 BUS_SPECIFIC_DATA;

    [WmiDataId(14),
     Description("In a multi-node system, this value identifies the node containing the memory in error") : amended
    ]
    uint16 MEM_NODE;

    [WmiDataId(15),
     Description("The Card number of the memory error location") : amended
    ]
    uint16 MEM_CARD;

    [WmiDataId(16),
     Description("The Module or RANK number of the memory error location") : amended
    ]
    uint16 MEM_BANK;

    [WmiDataId(17),
     Description("The Device number of the memory error location") : amended
    ]
    uint16 xMEM_DEVICE;

    [WmiDataId(18),
     Description("The module or rank number of the memory error location") : amended
    ]
    uint16 MEM_MODULE;

    [WmiDataId(19),
     Description("The Row number of the memory error location") : amended
    ]
    uint16 MEM_ROW;

    [WmiDataId(20),
     Description("The Column number of the memory error location") : amended
    ]
    uint16 MEM_COLUMN;

    [WmiDataId(21),
     Description("Bit position specifies the bit within the memory word that is in error") : amended
    ]
    uint16 MEM_BIT_POSITION;

    [WmiDataId(22),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(23),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{A14A5594-25DE-410e-9B92-80F0801AEC07}"),
 Description("MCA PCI Bus Error Event") : amended
]
class MSMCAEvent_PCIBusError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"},
     BitValues{"PCI_BUS_ERROR_STATUS is valid",
            "PCI_BUS_ERROR_TYPE is valid",
            "PCI_BUS_ID is valid",
            "PCI_BUS_ADDRESS is valid",
            "PCI_BUS_DATA is valid",
            "PCI_BUS_CMD is valid",
            "PCI_BUS_REQUESTOR_ID is valid",
            "PCI_BUS_RESPONDER_ID is valid",
            "PCI_BUS_TARGET_ID is valid",
            "PCI_BUS_OEM_ID is valid",
            "PCI_BUS_OEM_DATA_STRUCT is valid"} : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Bus Error Type") : amended
    ]
    uint64 PCI_BUS_ERROR_STATUS;

    [WmiDataId(8),
     Description("Memory or IO address on the PCI bus at the time of the event") : amended
    ]
    uint64 PCI_BUS_ADDRESS;

    [WmiDataId(9),
     Description("Data on the PCI bus at the time of the event") : amended
    ]
    uint64 PCI_BUS_DATA;

    [WmiDataId(10),
     Description("Bus command or operation at the time of the event") : amended
    ]
    uint64 PCI_BUS_CMD;

    [WmiDataId(11),
     Description("PCI Bus Requetor ID at the time of the event") : amended
    ]
    uint64 PCI_BUS_REQUESTOR_ID;

    [WmiDataId(12),
     Description("PCI Bus Responder ID at the time of the event") : amended
    ]
    uint64 PCI_BUS_RESPONDER_ID;

    [WmiDataId(13),
     Description("PCI Bus Intended Target ID at the time of the event") : amended
    ]
    uint64 PCI_BUS_TARGET_ID;

    [WmiDataId(14),
     Description("PCI Bus Error Types") : amended,
     Values{"0", "1", "2", "3", "4", "5", "6", "7"},
     ValueMap{"Unknown or OEM System Specific Error",
              "Data Parity Error",
              "System Error",
              "Master Abort",
              "Bus Time Out or No Device Present (No DEVSEL#)",
              "Master Data Parity Error",
              "Address Parity Error",
              "Command Parity Error" } : amended
    ]
    uint16 PCI_BUS_ERROR_TYPE;

    [WmiDataId(15),
     Description("Designated PCI Bus Identifier encountering error") : amended
    ]
    uint8 PCI_BUS_ID_BusNumber;

    [WmiDataId(16),
     Description("Designated PCI Bus Identifier encountering error") : amended
    ]
    uint8 PCI_BUS_ID_SegmentNumber;

    [WmiDataId(17),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(18),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{805CAF4E-336C-4eb2-8C0C-02F351CBF13C}"),
 Description("MCA PCI Platform Component Error Event") : amended
]
class MSMCAEvent_PCIComponentError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Description("Type of eventlog message") : amended,
     Values{},
     ValueMap{}
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0", "1", "2", "3", "4"},
     BitValues{"PCI_COMP_ERROR_STATUS is valid",
            "PCI_COMP_INFO is valid",
            "PCI_COMP_MEM_NUM is valid",
            "PCI_COMP_IO_NUM is valid",
            "PCI_COMP_REGS_DATA_PAIR is valid"} : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Internal Error Code") : amended
    ]
    uint64 PCI_COMP_ERROR_STATUS;

    [WmiDataId(8),
     Description("PCI Component Information - VendorId") : amended
    ]
    uint16 PCI_COMP_INFO_VendorId;

    [WmiDataId(9),
     Description("PCI Component Information - DeviceId") : amended
    ]
    uint16 PCI_COMP_INFO_DeviceId;

    [WmiDataId(10),
     Description("PCI Component Information - Class Code Interface") : amended
    ]
    uint8 PCI_COMP_INFO_ClassCodeInterface;

    [WmiDataId(11),
     Description("PCI Component Information - Class Code SubClass") : amended
    ]
    uint8 PCI_COMP_INFO_ClassCodeSubClass;

    [WmiDataId(12),
     Description("PCI Component Information - Class Code Base Class") : amended
    ]
    uint8 PCI_COMP_INFO_ClassCodeBaseClass;

    [WmiDataId(13),
     Description("PCI Component Information - Function Number") : amended
    ]
    uint8 PCI_COMP_INFO_FunctionNumber;

    [WmiDataId(14),
     Description("PCI Component Information - Device Number") : amended
    ]
    uint8 PCI_COMP_INFO_DeviceNumber;

    [WmiDataId(15),
     Description("PCI Component Information - Bus Number") : amended
    ]
    uint8 PCI_COMP_INFO_BusNumber;

    [WmiDataId(16),
     Description("PCI Component Information - Segment Number") : amended
    ]
    uint8 PCI_COMP_INFO_SegmentNumber;

    [WmiDataId(17),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(18),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{BDBA4B12-8D00-4570-B9B2-3FDECF1D5661}"),
 Description("MCA Platform IPMI System Eventlog Error Event") : amended
]
class MSMCAEvent_SystemEventError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Description("Type of eventlog message") : amended,
     Values{},
     ValueMap{}
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
     BitValues{"SEL_RECORD_ID is valid",
            "SEL_RECORD_TYPE is valid",
            "SEL_GENERATOR_ID is valid",
            "SEL_EVM_REV is valid",
            "SEL_SENSOR_TYPE is valid",
            "SEL_SENSOR_NUM is valid",
            "SEL_EVENT_DIR is valid",
            "SEL_EVENT_DATA1 is valid",
            "SEL_EVENT_DATA2 is valid",
            "SEL_EVENT_DATA3 is valid"} : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Timestamp of the event log") : amended
    ]
    uint64 SEL_TIME_STAMP;

    [WmiDataId(8),
     Description("Record ID used for SEL access") : amended
    ]
    uint16 SEL_RECORD_ID;

    [WmiDataId(9),
     Description("Software ID if event was generated by software") : amended
    ]
    uint16 SEL_GENERATOR_ID;

    [WmiDataId(10),
     Description("Indicates the record type") : amended
    ]
    uint8 SEL_RECORD_TYPE;

    [WmiDataId(11),
     Description("The error message format version") : amended
    ]
    uint8 SEL_EVM_REV;

    [WmiDataId(12),
     Description("Sensor type code of the sensor that generated the event") : amended
    ]
    uint8 SEL_SENSOR_TYPE;

    [WmiDataId(13),
     Description("Number of the sensor that generated the event") : amended
    ]
    uint8 SEL_SENSOR_NUM;

    [WmiDataId(14),
     Description("Event Dir") : amended
    ]
    uint8 SEL_EVENT_DIR_TYPE;

    [WmiDataId(15),
     Description("Event Data Field 1") : amended
    ]
    uint8 SEL_DATA1;

    [WmiDataId(16),
     Description("Event Data Field 2") : amended
    ]
    uint8 SEL_DATA2;

    [WmiDataId(17),
     Description("Event Data Field 3") : amended
    ]
    uint8 SEL_DATA3;

    [WmiDataId(18),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(19),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{4184DF1B-EDFE-406b-B172-54C91FBD9BAF}"),
 Description("MCA SMBIOS Error Event") : amended
]
class MSMCAEvent_SMBIOSError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0"},
     BitValues{"SMBIOS_EVENT_TYPE is valid"} : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Event Type") : amended,
     Values{"0", "1", "2", "3", "4", "5", "6", "7",
            "8", "9", "10", "11", "12", "13", "14", "15",
            "16", "17", "18", "19", "20", "21", "22", "23"},
     ValueMap{"Reserved",
              "Single bit ECC memory error",
              "Multiple bit ECC memory error",
              "Parity Memory error",
              "Bus time-out",
              "I/O Channel Check",
              "Software NMI",
              "POST Memory Resize",
              "POST Error",
              "PCI Parity Error",
              "PCI System Error",
              "CPU Failure",
              "EISA FailSafe Timer timeout",
              "Correctable memory log disabled",
              "Logging disabled for a specific event type. Too many errors of the same type received in a short amount of time",
              "Reserved",
              "System limit exceeded (e.g. voltage or temperature threshold exceeded",
              "Asynchronous hardware timer expired and issued a system reset",
              "System configuration information",
              "Hard disk information",
              "System reconfigured",
              "Uncorrectable CPU-complex error",
              "Log Area Reset/Cleared",
              "System boot. If implemented this log entry is guaranteed to be the first one written on any system boot"
              } : amended
    ]
    uint8 SMBIOS_EVENT_TYPE;

    [WmiDataId(8),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(9),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};



[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{2D2434AA-EF83-4200-BA24-DE366C415F7B}"),
 Description("MCA Platform Specific Error Event") : amended
]
class MSMCAEvent_PlatformSpecificError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Validation bits to indicate the validity of the subsequent fields") : amended,
     BitMap{"0", "1", "2", "3", "4", "5", "6", "7"},
     BitValues{"PLATFORM_ERROR_STATUS is valid",
            "PLATFORM_ERROR_REQUESTOR_ID is valid",
            "PLATFORM_ERROR_RESPONDER_ID is valid",
            "PLATFORM_ERROR_TARGET is valid",
            "PLATFORM_ERROR_SPECIFIC_DATA is valid",
            "PLATFORM_ERROR_OEM_ID is valid",
            "PLATFORM_ERROR_OEM_DATA_STRUCT is valid",
            "PLATFORM_ERROR_OEM_DEVICE_PATH is valid"
           } : amended
    ]
    uint64 VALIDATION_BITS;

    [WmiDataId(7),
     Description("Platform generic error status") : amended
    ]
    uint64 PLATFORM_ERROR_STATUS;

    [WmiDataId(8),
     Description("Requestor ID at time of the event") : amended
    ]
    uint64 PLATFORM_REQUESTOR_ID;

    [WmiDataId(9),
     Description("Responder ID at time of the event") : amended
    ]
    uint64 PLATFORM_RESPONDER_ID;

    [WmiDataId(10),
     Description("Target ID at the time of the event") : amended
    ]
    uint64 PLATFORM_TARGET_ID;

    [WmiDataId(11),
     Description("OEM specific bus dependent data") : amended
    ]
    uint64 PLATFORM_BUS_SPECIFIC_DATA;

    [WmiDataId(12),
     Description("A unique ID of the component reporting the error") : amended
    ]
    uint8 OEM_COMPONENT_ID[16];

    [WmiDataId(13),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(14),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{477B769B-785C-48dd-A02E-57E051BE7B85}"),
 Description("MCA Unknown Error Event") : amended
]
class MSMCAEvent_InvalidError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     Values{ "0", "1", "2" },
     ValueMap{"Recoverable", "Fatal", "Correctable"},
     Description("Severity of the error record") : amended
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     Values{} : amended,
     ValueMap{},
     Description("Type of eventlog message") : amended
    ]
    uint32 Type;

    [WmiDataId(4),
     Description("CPU that reported the error") : amended
    ]
    uint32 Cpu;

    [WmiDataId(5),
     Description("Number of additional errors in the record") : amended
    ]
    uint32 AdditionalErrors;

    [WmiDataId(6),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(7),
     WmiSizeIs("Size"),
     Description("Raw Error Record") : amended
    ]
    uint8 RawRecord[];
};



[WMI,
 Description("An MCA/CMC/CPE event") : amended,
 guid("{9E77A308-6B82-4fc1-AB41-0A55867C35C2}")
]
class MSMCAInfo_Entry : MSMCAInfo
{
    [WmiDataId(1),
     read]
    uint32 Length;

    [WmiDataId(2),
     read,
     WmiSizeIs("Length")]
    uint8 Data[];
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This contains the raw MCA logs") : amended,
 guid("{23602A8A-DADD-462f-9AE5-30FA2C37DD5B}")
 ]
class MSMCAInfo_RawMCAData : MSMCAInfo
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     WmiSizeIs("Count")]
    MSMCAInfo_Entry Records[];    
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This contains a CMC event") : amended,
 guid("{2F1A8A9D-7988-457f-A17A-8979E82043C5}")
 ]
class MSMCAInfo_RawCMCEvent : WmiEvent
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     WmiSizeIs("Count")]
    MSMCAInfo_Entry Records[];
    
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This contains a MCA event") : amended,
 guid("{2F1A8A9F-7988-457f-A17A-8979E82043C5}")
 ]
class MSMCAInfo_RawMCAEvent : WmiEvent
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     WmiSizeIs("Count")]
    MSMCAInfo_Entry Records[];
    
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This contains a Corrected Platform event") : amended,
 guid("{6B629D5E-E63C-48a3-9EBB-974227075265}")
 ]
class MSMCAInfo_RawCorrectedPlatformEvent : WmiEvent
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     WmiSizeIs("Count")]
    MSMCAInfo_Entry Records[];    
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This contains the raw MCA logs") : amended,
 guid("{A648EC0D-7E9B-4e6c-8787-1478151CD04B}")
 ]
class MSMCAInfo_CPEControl : MSMCAInfo
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read,
     write]
     uint32 CPEPollingInterval;

    [WmiDataId(2),
     read,
     write]
     boolean CPEGenerationEnabled;

};

//
// Power management classes

[abstract]
class MSPower
{
};
[Dynamic, Provider("WMIProv"),
 WMI,
 Description("The control sets whether the device should dynamically power on and off while the system is working.") : amended,
 guid("827c0a6f-feb0-11d0-bd26-00aa00b7b32a")
 ]
class MSPower_DeviceEnable : MSPower
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read,
     write] boolean Enable;
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("This control indicates whether the device should be configured to wake a sleeping system.") : amended,
 guid("a9546a82-feb0-11d0-bd26-00aa00b7b32a")
 ]
class MSPower_DeviceWakeEnable : MSPower
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read,
     write] boolean Enable;
};


//
// NDIS classes

[abstract]
class MSNdis
{
};

[WMI,
  guid("{B5BD98B7-0201-11d1-A50E-00A0C9062910}")]
class MSNdis_NetworkAddress : MSNdis
{
    [read, WmiDataId(1),
     DisplayName("Address") : amended
    ]
      uint8    Address[6];
};

[WMI,
 guid("{B5BD98B8-0201-11d1-A50E-00A0C9062910}")]
class MSNdis_NetworkShortAddress : MSNdis
{
    [read, WmiDataId(1)
    ]
      uint8    Address[2];
};

[WMI,
 guid("{60fc6b57-0f66-11d1-96a7-00c04fc3358c}")]
class MSNdis_NetworkLinkSpeed : MSNdis
{
        [read, WmiDataId(1)]    uint32  Outbound;
        [
        read, WmiDataId(2)]    uint32  Inbound;
};

///
///     GUIDs that do not translate to OIDs
///
///

[WMI, Dynamic, Provider("WMIProv"),
 guid("{981f2d7f-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Enumerate Adapter") : amended]
class MSNdis_EnumerateAdapter : MSNdis
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [
    read,
     Description("Device name.") : amended,
     WmiDataId(1)]    string    DeviceName;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{981f2d80-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Notify Adapter Removal") : amended]
class MSNdis_NotifyAdapterRemoval : WMIEvent
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [
    read,
     Description("Device name.") : amended,
     WmiDataId(1)]    string    DeviceName;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{981f2d81-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Notify Adapter Arrival") : amended]
class MSNdis_NotifyAdapterArrival : WMIEvent
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [
    read,
     Description("Device name.") : amended,
     WmiDataId(1)]    string    DeviceName;
};


[WMI, Dynamic, Provider("WMIProv"),
 guid("{981f2d82-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Enumerate VC") : amended]
class MSNdis_NdisEnumerateVc : MSNdis
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{981f2d79-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Notify VC Removal") : amended]
class MSNdis_NotifyVcRemoval : WmiEvent
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{182f9e0c-b1f3-11d0-8dd7-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Notify VC Arrival") : amended]
class MSNdis_NotifyVcArrival : WMIEvent
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;
};


[WMI, Dynamic, Provider("WMIProv"),
 guid("{a14f1c97-8839-4f8a-9996-a28996ebbf1d}"),
 WmiExpense(1),
 Description("This control decides whether the network device should wake up the system only on receiving a Magic packet") : amended]
class MSNdis_DeviceWakeOnMagicPacketOnly : MSNdis
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [read, write,
     WmiDataId(1)]    boolean   EnableWakeOnMagicPacketOnly;
};


///
///
///     General GUIDs
///
///
[WMI, Dynamic, Provider("WMIProv"),
 guid("{5ec10354-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Hardware Status") : amended]
class MSNdis_HardwareStatus : MSNdis
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [read,
     Description("Current hardware status of the underlying NIC.") : amended,
     Values{"NdisHardwareStatusReady",
             "NdisHardwareStatusInitializing",
             "NdisHardwareStatusReset",
             "NdisHardwareStatusClosing",
             "NdisHardwarestatusNotReady"} : amended,
     ValueMap{"0",
             "1",
             "2",
             "3",
             "4"},
     WmiDataId(1)]    uint32    NdisHardwareStatus;

//
//      This is of the type:
//      typedef enum _NDIS_HARDWARE_STATUS
//      {
//              NdisHardwareStatusReady,
//              NdisHardwareStatusInitializing,
//              NdisHardwareStatusReset,
//              NdisHardwareStatusClosing,
//              NdisHardwarestatusNotReady
//      } NDIS_HARDWARE_STATUS, *PNDIS_HARDWARE_STATUS;
//
};

[WMI,Dynamic, Provider("WMIProv"),
 guid("{5ec10355-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Media Types Supported") : amended]
class MSNdis_MediaSupported : MSNdis
{
    [key, read]
        string          InstanceName;

    [read]
    boolean             Active;

        [
        read,
        Description("Number of media types supported.") : amended,
                WmiDataId(1)]    uint32  NumberElements;
    [read,
        Description("List of media types the NIC supports.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    uint32    NdisMediaSupported[];
};

[WMI,Dynamic, Provider("WMIProv"),
 guid("{5ec10356-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Media Types In Use") : amended]
class  MSNdis_MediaInUse : MSNdis
{
    [key, read]
        string          InstanceName;

    [read]
        boolean         Active;

        [
        read,
        Description("Number of media types in use.") : amended,
                WmiDataId(1)]    uint32  NumberElements;
    [read,
        Description("List of media types the NIC is currently supporting.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    uint32    NdisMediaInUse[];
};

[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10357-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Maximum Lookahead Supported") : amended]
class  MSNdis_MaximumLookahead : MSNdis
{
    [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
        Description("The maximum number of bytes the NIC can always provide as lookahead data.") : amended,
                WmiDataId(1)]    uint32    NdisMaximumLookahead;
};



[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10358-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Maximum Frame Size") : amended]
class  MSNdis_MaximumFrameSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum network packet size in bytes the NIC supports, not including a header.") : amended,
                WmiDataId(1)]    uint32    NdisMaximumFrameSize;
};

[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10359-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Link Speed") : amended]
class  MSNdis_LinkSpeed : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum speed of the NIC (kbps).") : amended,
                WmiDataId(1)]    uint32    NdisLinkSpeed;
};

[WMI, Dynamic, Provider("WMIProv"),guid("{5ec1035a-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Transmit Buffer Space") : amended]

class  MSNdis_TransmitBufferSpace : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The amount of memory, in bytes, on the NIC available for buffering transmit data.") : amended,
                WmiDataId(1)]    uint32    NdisTransmitBufferSpace;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035b-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Receive Buffer Space") : amended]
class  MSNdis_ReceiveBufferSpace : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The amount of memory on the NIC available for buffering receive data.") : amended,
                WmiDataId(1)]    uint32    NdisReceiveBufferSpace;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035c-a61a-11d0-8dd4-00c04fc3358c}"),
 WmiExpense(1),
 Description("NDIS Transmit Block Size") : amended]
class  MSNdis_TransmitBlockSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The minimum number of bytes that a single net packet occupies in the transmit buffer space of the NIC.") : amended,
                WmiDataId(1)]    uint32    NdisTransmitBlockSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035d-a61a-11d0-8dd4-00c04fc3358c}"),
 Description("NDIS Receive Block Size") : amended]
class  MSNdis_ReceiveBlockSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("The amount of storage, in bytes, that a single packet occupies in the receive buffer space of the NIC.") : amended,
                WmiDataId(1)]    uint32    NdisReceiveBlockSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035e-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Vendor ID") : amended]
class  MSNdis_VendorID : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("A three-byte IEEE-registered vendor code, followed by a single byte the vendor assigns to identify a particular NIC.") : amended,
                WmiDataId(1)]    uint32    NdisVendorID;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035f-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Vendor Description") : amended
 ]
class  MSNdis_VendorDescription : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Zero-terminated string describing the NIC.") : amended,
                WmiDataId(1)]    string    NdisVendorDescription;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10360-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Current Packet Filter") : amended]
class  MSNdis_CurrentPacketFilter : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Current packet types that will be received and indicated by the NIC.") : amended,
                WmiDataId(1)]    uint32    NdisCurrentPacketFilter;

//
//      This is an inclusive OR of the following types:
//
//      NDIS_PACKET_TYPE_DIRECTED               0x00000001
//      NDIS_PACKET_TYPE_MULTICAST              0x00000002
//      NDIS_PACKET_TYPE_ALL_MULTICAST          0x00000004
//      NDIS_PACKET_TYPE_BROADCAST              0x00000008
//      NDIS_PACKET_TYPE_SOURCE_ROUTING         0x00000010
//      NDIS_PACKET_TYPE_PROMISCUOUS            0x00000020
//      NDIS_PACKET_TYPE_SMT                    0x00000040
//      NDIS_PACKET_TYPE_ALL_LOCAL              0x00000080
//      NDIS_PACKET_TYPE_GROUP                  0x00001000
//      NDIS_PACKET_TYPE_ALL_FUNCTIONAL         0x00002000
//      NDIS_PACKET_TYPE_FUNCTIONAL             0x00004000
//      NDIS_PACKET_TYPE_MAC_FRAME              0x00008000
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10361-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Current Lookahead") : amended]
class  MSNdis_CurrentLookahead : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of bytes of received packet data, excluding the header, that will be indicated to the protocol driver.") : amended,
                WmiDataId(1)]    uint32    NdisCurrentLookahead;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10362-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Driver Version") : amended]
class  MSNdis_DriverVersion : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The NDIS version in use by the NIC driver.") : amended,
                WmiDataId(1)]    uint16    NdisDriverVersion;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10363-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Maximum Packet Total Size") : amended]

class  MSNdis_MaximumTotalSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum total packet length, in bytes, the NIC supports, including the header.") : amended,
                WmiDataId(1)]    uint32    NdisMaximumTotalSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10365-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS MAC Options") : amended]
class  MSNdis_MacOptions : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("A bitmask that defines optional properties of the underlying driver or its NIC.") : amended,
                WmiDataId(1)]    uint32    NdisMacOptions;

//
//      This is an inclusive OR of the following types:
//      
//      NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA     0x00000001
//      NDIS_MAC_OPTION_RECEIVE_SERIALIZED      0x00000002
//      NDIS_MAC_OPTION_TRANSFERS_NOT_PEND      0x00000004
//      NDIS_MAC_OPTION_NO_LOOPBACK             0x00000008
//      NDIS_MAC_OPTION_FULL_DUPLEX             0x00000010
//      NDIS_MAC_OPTION_EOTX_INDICATION         0x00000020
//      NDIS_MAC_OPTION_RESERVED                0x80000000
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10366-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Media Connect Status") : amended]
class  MSNdis_MediaConnectStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The connection status of the NIC on the network.") : amended,
        Values{"NdisMediaStateConnected",
                "NdisMediaStateDisconnected"} : amended,
        ValueMap{"0",
                "1"},
                WmiDataId(1)]    uint32    NdisMediaConnectStatus;

//
//
//
// Defines the state of the LAN media
//
//      typedef enum _NDIS_MEDIA_STATE
//      {
//              NdisMediaStateConnected,
//              NdisMediaStateDisconnected
//      } NDIS_MEDIA_STATE, *PNDIS_MEDIA_STATE;
//
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10367-a61a-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Maximum Send Packets") : amended]
class  MSNdis_MaximumSendPackets : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum number of send packets the MiniportSendPackets function can accept.") : amended,
                WmiDataId(1)]    uint32    NdisMaximumSendPackets;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{447956f9-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Vendor's Driver Version") : amended]
class  MSNdis_VendorDriverVersion : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The vendor-assigned version number of the NIC driver.") : amended,
                WmiDataId(1)]    uint32    NdisVendorDriverVersion;
};

///
///     OID_GEN_VLAN_ID:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{765dc702-c5e8-4b67-843b-3f5a4ff2648b}"),

 WmiExpense(1),
 Description("NDIS VLAN Identifier") : amended]
class  MSNdis_VlanIdentifier : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read, write,
        Description("The IEEE 802.1Q VLAN ID assigned to this NIC.") : amended,
                WmiDataId(1)]    uint32    NdisVlanId;
};


//
//  OID_GEN_PHYSICAL_MEDIUM:
//

[WMI, Dynamic, Provider("WMIProv"), guid("{418ca16d-3937-4208-940a-ec6196278085}"),

 WmiExpense(1),
 Description("NDIS Physical Medium Type") : amended]
class  MSNdis_PhysicalMediumType : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The physical medium type of the NIC.") : amended,
                WmiDataId(1)]    uint32    NdisPhysicalMediumType;
//  Defines the physical medium type of the NIC
//
// typedef enum _NDIS_PHYSICAL_MEDIUM
// {
//
//    NdisPhysicalMediumUnspecified,
//    NdisPhysicalMediumWirelessLan,
//    NdisPhysicalMediumCableModem,
//    NdisPhysicalMediumPhoneLine,
//    NdisPhysicalMediumPowerLine,
//    NdisPhysicalMediumDSL,        // includes ADSL and UADSL (G.Lite)
//    NdisPhysicalMediumFibreChannel,
//    NdisPhysicalMedium1394,
//    NdisPhysicalMediumWirelessWan,
//    NdisPhysicalMediumMax         // Not a real physical type, defined as an upper-bound
// } NDIS_PHYSICAL_MEDIUM, *PNDIS_PHYSICAL_MEDIUM;
//
};



[WMI, Dynamic, Provider("WMIProv"), guid("{447956fa-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Transmits OK") : amended]
class  MSNdis_TransmitsOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames transmitted without errors.") : amended,
                WmiDataId(1)]    uint64    NdisTransmitsOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{447956fb-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Receives OK") : amended]
class  MSNdis_ReceivesOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames the NIC receives without errors and indicates to bound protocols.") : amended,
                WmiDataId(1)]    uint64    NdisReceivesOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{447956fc-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Transmit Errors") : amended]
class  MSNdis_TransmitsError : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames a NIC fails to transmit.") : amended,
                WmiDataId(1)]    uint32    NdisTransmitsError;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{447956fd-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Receive Errors") : amended]
class  MSNdis_ReceiveError : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames a NIC receives but does not indicate to the protocols due to errors.") : amended,
                WmiDataId(1)]    uint32    NdisReceiveError;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{447956fe-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Receive No Buffer") : amended]
class  MSNdis_ReceiveNoBuffer : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("The number of frames the NIC cannot receive due to lack of NIC receive buffer space.") : amended,
                WmiDataId(1)]    uint32    NdisReceiveNoBuffer;
};

///
///
///     CoNDIS general GUIDs
///
///

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad192-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Hardware Status") : amended]
class  MSNdis_CoHardwareStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
     Description("Current hardware status of the underlying NIC.") : amended,
                WmiDataId(1)]    uint32 NdisCoHardwareStatus;
};


[WMI, Dynamic, Provider("WMIProv"), guid("{791ad193-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Media Types Supported") : amended]
class  MSNdis_CoMediaSupported : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Number of media types supported.") : amended,
                WmiDataId(1)]    uint32  NumberElements;
    [read,
        Description("List of media types the NIC supports.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    uint32    NdisCoMediaSupported[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad194-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Media Types In Use") : amended]
class  MSNdis_CoMediaInUse : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Number of media types in use.") : amended,
                WmiDataId(1)]    uint32  NumberElements;
    [read,
        Description("List of media types the NIC is currently supporting.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    uint32    NdisCoMediaInUse[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad195-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Link Speed") : amended]
class  MSNdis_CoLinkSpeed : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [DisplayName("NdisCoLinkSpeed") : amended,
        read,
        Description("The maximum inbound and outbound speeds of the NIC (kbps).") : amended,
                WmiDataId(1)]   MSNdis_NetworkLinkSpeed NdisCoLinkSpeed;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad196-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Vendor ID") : amended]
class  MSNdis_CoVendorId : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("A three-byte IEEE-registered vendor code, followed by a single byte the vendor assigns to identify a particular NIC.") : amended,
                WmiDataId(1)]    uint32    NdisCoVendorID;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad197-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Vendor Description") : amended]
class  MSNdis_CoVendorDescription : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Zero-terminated string describing the NIC.") : amended,
                WmiDataId(1)]    string    NdisCoVendorDescription;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad198-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Driver Version") : amended]
class  MSNdis_CoDriverVersion : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The NDIS version in use by the NIC driver.") : amended,
                WmiDataId(1)]    uint16    NdisCoDriverVersion;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19a-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS MAC Options") : amended]
class  MSNdis_CoMacOptions : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("A bitmask that defines optional properties of the underlying driver or its NIC.") : amended,
                WmiDataId(1)]    uint32    NdisCoMacOptions;
//
//
//      NDIS MAC option bits for OID_GEN_CO_MAC_OPTIONS.
//
//              #define NDIS_CO_MAC_OPTION_DYNAMIC_LINK_SPEED   0x00000001
//
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19b-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Media Connect Status") : amended]

class  MSNdis_CoMediaConnectStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The connection status of the NIC on the network.") : amended,
        Values{"NdisMediaStateConnected",
                "NdisMediaStateDisconnected"} : amended,
        ValueMap{"0",
                "1"},
                WmiDataId(1)]    uint32    NdisCoMediaConnectStatus;
//
//
//
// Defines the state of the LAN media
//
//      typedef enum _NDIS_MEDIA_STATE
//      {
//              NdisMediaStateConnected,
//              NdisMediaStateDisconnected
//      } NDIS_MEDIA_STATE, *PNDIS_MEDIA_STATE;
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19c-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Vendor's Driver Version") : amended]
class  MSNdis_CoVendorDriverVersion : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [DisplayName("NdisCoVendorDriverVersion") : amended,
        read,
        Description("The vendor-assigned version number of the NIC driver.") : amended,
                WmiDataId(1)]    uint32    NdisCoVendorDriverVersion;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19d-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Minimum Link Speed") : amended]
class  MSNdis_CoMinimumLinkSpeed : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum inbound and outbound speeds of the NIC (kbps).") : amended,
                WmiDataId(1)]   MSNdis_NetworkLinkSpeed NdisCoMinimumLinkSpeed;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a214805-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Transmits PDUs OK") : amended]
class  MSNdis_CoTransmitPdusOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of PDUs transmitted without errors") : amended,
                WmiDataId(1)]    uint64    NdisCoTransmitPdusOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a214806-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Receive PDUs OK") : amended]
class  MSNdis_CoReceivePdusOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of PDUs the NIC receives without errors and indicates to bound protocols.") : amended,
                WmiDataId(1)]    uint64    NdisCoReceivePdusOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a214807-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Transmit PDU Errors") : amended]
class  MSNdis_CoTransmitPduErrors : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of PDUs a NIC fails to transmit.") : amended,
                WmiDataId(1)]    uint32    NdisCoTransmitPduErrors;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a214808-e35f-11d0-9692-00c04fc3358c}"),
WmiExpense(1),
 Description("CoNDIS Receive PDU Errors") : amended]
class  MSNdis_CoReceivePduErrors : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of PDUs a NIC receives but does not indicate to the protocols due to errors.") : amended,
                WmiDataId(1)]    uint32    NdisCoReceivePduErrors;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a214809-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("CoNDIS Receive PDUs No Buffer") : amended]
class  MSNdis_CoReceivePdusNoBuffer : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of PDUs the NIC cannot receive due to lack of NIC receive buffer space.") : amended,
                WmiDataId(1)]    uint32    NdisCoReceivePdusNoBuffer;
};

///
///
///     ATM media specific GUIDs
///
///
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19e-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Supported VC Rates") : amended]
class  MSNdis_AtmSupportedVcRates : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Minimum cell rate supported.") : amended,
                WmiDataId(1)]    uint32 MinCellRate;

        [
        read,
                Description("Maximum cell rate supported.") : amended,
                WmiDataId(2)]   uint32  MaxCellRate;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19f-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Supported Service Category") : amended]
class  MSNdis_AtmSupportedServiceCategory : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Bit mask defining the service categories supported by the hardware.") : amended,
                WmiDataId(1)]    uint32 NdisAtmSupportedServiceCategory;

//
//      This can be a combination of following defines:
//
//      #define ATM_SERVICE_CATEGORY_CBR    1   // Constant Bit Rate
//      #define ATM_SERVICE_CATEGORY_VBR    2   // Variable Bit Rate
//      #define ATM_SERVICE_CATEGORY_UBR    4   // Unspecified Bit Rate
//      #define ATM_SERVICE_CATEGORY_ABR    8   // Available Bit Rate
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a0-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Supported AAL Types") : amended]
class  MSNdis_AtmSupportedAalTypes : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Bit mask defining the AAL types supported by the hardware.") : amended,
                WmiDataId(1)]    uint32 NdisAtmSupportedAalTypes;
//
//      This can be a combination of the following defines:
//
//      #define AAL_TYPE_AAL0           1
//      #define AAL_TYPE_AAL1           2
//      #define AAL_TYPE_AAL34          4
//      #define AAL_TYPE_AAL5           8
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a1-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Hardware Current Address") : amended]
class  MSNdis_AtmHardwareCurrentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The address of the NIC encoded in the hardware.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisAtmHardwareCurrentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a2-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum Active VCs") : amended]
class  MSNdis_AtmMaxActiveVcs : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Maximum number of active VCs the adapter can support.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxActiveVcs;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a3-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum Active VCI Bits") : amended]
class  MSNdis_AtmMaxActiveVciBits : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of bits controllable in the VCI field of the cell header.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxActiveVciBits;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a4-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum Active VPI Bits") : amended]
class  MSNdis_AtmMaxActiveVpiBits : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of bits controllable in the VPI field of the cell header.") : amended,
                WmiDataId(1)]   uint32  NdisAtmMaxActiveVpiBits;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a5-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum AAL0 Packet Size") : amended]
class  MSNdis_AtmMaxAal0PacketSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Maximum supported size for AAL0 packets.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxAal0PacketSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a6-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum AAL1 Packet Size") : amended]
class  MSNdis_AtmMaxAal1PacketSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("Maximum supported size for AAL1 packets.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxAal1PacketSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a7-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum AAL3/4 Packet Size") : amended]
class  MSNdis_AtmMaxAal34PacketSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("Maximum supported size for AAL3/4 packets.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxAal34PacketSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{791ad191-e35c-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Maximum AAL5 Packet Size") : amended]
class  MSNdis_AtmMaxAal5PacketSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Maximum supported size for AAL5 packets.") : amended,
                WmiDataId(1)]    uint32 NdisAtmMaxAal5PacketSize;
};


[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480a-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Receive Cells OK") : amended]
class  MSNdis_AtmReceiveCellsOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of cells the NIC has received without errors.") : amended,
                WmiDataId(1)]    uint64 NdisAtmReceiveCellsOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480b-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Transmit Cells OK") : amended]
class  MSNdis_AtmTransmitCellsOk : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of cells the NIC has transmitted without errors.") : amended,
                WmiDataId(1)]    uint64 NdisAtmTransmitCellsOk;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480c-e35f-11d0-9692-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS ATM Receive Cells Dropped") : amended]
class  MSNdis_AtmReceiveCellsDropped : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of receive cells the NIC has dropped.") : amended,
                WmiDataId(1)]    uint64 NdisAtmReceiveCellsDropped;
};

///
///
///     Ethernet specific GUIDs
///     
///

[WMI, Dynamic, Provider("WMIProv"), guid("{447956ff-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet Permanent Address") : amended]
class  MSNdis_EthernetPermanentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("The address of the NIC encoded in the hardware.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisPermanentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795700-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet Current Address") : amended]
class  MSNdis_EthernetCurrentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("The address the NIC is currently using.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisCurrentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795701-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet Multicast List") : amended]
class  MSNdis_EthernetMulticastList : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [        read,
        Description("Number of multicast addresses enabled on the NIC.") : amended,
                WmiDataId(1)] uint32 NumberElements;

        [read,
        Description("The multicast address list on the NIC enabled for packet reception.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    MSNdis_NetworkAddress NdisMulticastList[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795702-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("Adpater Ethernet Maximum Multicast List Size") : amended]
class  MSNdis_EthernetMaximumMulticastListSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The maximum number of multicast addresses the NIC driver can manage.") : amended,
                WmiDataId(1)]    uint32    NdisEthernetMaximumMulticastListSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795703-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet MAC Options") : amended]
class  MSNdis_EthernetMacOptions : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("Features supported by the underlying driver, which could be emulating Ethernet.") : amended,
                WmiDataId(1)]    uint32    NdisEthernetMacOptions;

//
//      Supported values:
//
//              NDIS_802_3_MAC_OPTION_PRIORITY          0x00000001
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795704-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet Receive Error Alignment") : amended]
class  MSNdis_EthernetReceiveErrorAlignment : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames received with alignment errors.") : amended,
                WmiDataId(1)]    uint32    NdisEthernetReceiveErrorAlignment;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795705-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet One Transmit collision") : amended]
class    MSNdis_EthernetOneTransmitCollision : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames successfully transmitted after exactly one collision.") : amended,
                WmiDataId(1)]    uint32    NdisEthernetOneTransmitCollision;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795706-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Ethernet More Transmit collisions") : amended]
class  MSNdis_EthernetMoreTransmitCollisions : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The number of frames successfully transmitted after more than one collision.") : amended,
                WmiDataId(1)]    uint32    NdisEthernetMoreTransmitCollisions;
};

///
///
///     Token Ring specific GUIDs
///
///
[WMI, Dynamic, Provider("WMIProv"), guid("{44795707-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Permanent Address") : amended]
class  MSNdis_TokenRingPermanentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The address of the NIC encoded in the hardware.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress  NdisPermanentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795708-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Current Address") : amended]
class  MSNdis_TokenRingCurrentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The address the NIC is currently using.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisCurrentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{44795709-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Current Functional Address") : amended]
class  MSNdis_TokenRingCurrentFunctional : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
                Description("The functional address enabled on the NIC for packet reception.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingCurrentFunctional;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{4479570a-a61b-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Current Group Address") : amended]
class  MSNdis_TokenRingCurrentGroup : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The group address enabled on the NIC for packet reception.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingCurrentGroup;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{4479570b-a61b-11d0-8dd4-00c04fc3358c}"),
WmiExpense(1),
 Description("NDIS Token Ring Last Open Status") : amended]
class  MSNdis_TokenRingLastOpenStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
        Description("The last open error status returned for a protocol's call to NdisOpenAdapter.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingLastOpenStatus;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{890a36ec-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Current Ring Status") : amended]
class  MSNdis_TokenRingCurrentRingStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
                Description("The last ring status indicated with an NDIS_RING_XXX status code.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingCurrentRingStatus;

//
//      This can be one of the following values:
//
//  NDIS_RING_SIGNAL_LOSS                   0x00008000
//  NDIS_RING_HARD_ERROR                    0x00004000
//  NDIS_RING_SOFT_ERROR                    0x00002000
//  NDIS_RING_TRANSMIT_BEACON               0x00001000
//  NDIS_RING_LOBE_WIRE_FAULT               0x00000800
//  NDIS_RING_AUTO_REMOVAL_ERROR            0x00000400
//  NDIS_RING_REMOVE_RECEIVED               0x00000200
//  NDIS_RING_COUNTER_OVERFLOW              0x00000100
//  NDIS_RING_SINGLE_STATION                0x00000080
//      NDIS_RING_RING_RECOVERY                 0x00000040
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14032-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Current Ring State.") : amended]
class  MSNdis_TokenRingCurrentRingState : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
        [
        read,
                Description("The state of the NIC driver with repsect to entering the ring.") : amended,
                Values{"NdisRingStateOpened",
                        "NdisRingStateClosed",
                        "NdisRingStateOpening",
                        "NdisRingStateClosing",
                        "NdisRingStateOpenFailure",
                        "NdisRingStateRingFailure"} : amended,
                ValueMap{"1",
                        "2",
                        "3",
                        "4",
                        "5",
                        "6"},
                WmiDataId(1)]    uint32    NdisTokenRingCurrentRingState;

//
//      This is defined as follows:
//
//              typedef enum _NDIS_802_5_RING_STATE
//              {
//              NdisRingStateOpened = 1,
//              NdisRingStateClosed,
//              NdisRingStateOpening,
//              NdisRingStateClosing,
//              NdisRingStateOpenFailure,
//              NdisRingStateRingFailure
//              } NDIS_802_5_RING_STATE, *PNDIS_802_5_RING_STATE;
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14033-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Line Errors") : amended]
class  MSNdis_TokenRingLineErrors : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of frames with an invalid FCS or a code violation.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingLineErrors;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14034-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Token Ring Lost Frames") : amended]
class  MSNdis_TokenRingLostFrames : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The number of frames transmitted that have not circled the ring within the maximum ring latency.") : amended,
                WmiDataId(1)]    uint32    NdisTokenRingLostFrames;
};

///
///
///     FDDI specific GUIDs
///
///

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14035-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Long Permanent Address") : amended]
class  MSNdis_FddiLongPermanentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The long address of the NIC encoded in the hardware.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisPermanentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14036-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Long Current Address") : amended]
class  MSNdis_FddiLongCurrentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The long address the NIC is currently using.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress     NdisCurrentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14037-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Long Multicast List") : amended]
class  MSNdis_FddiLongMulticastList : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of multicast addresses enabled on the NIC.") : amended,
                WmiDataId(1)] uint32 NumberElements;
    [read,
                    Description("The multicast long address list on the NIC enabled for packet reception.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]
                MSNdis_NetworkAddress NdisMulticastList[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14038-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Long Maximum List Size") : amended]
class  MSNdis_FddiLongMaximumListSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The maximum number of multicast long addresses the NIC driver can manage.") : amended,
                WmiDataId(1)]    uint32    NdisFddiLongMaximumListSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14039-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Short Permanent Address") : amended]
class  MSNdis_FddiShortPermanentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The short address of the NIC encoded in the hardware.") : amended,
                WmiDataId(1)]    MSNdis_NetworkShortAddress     NdisPermanentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403a-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Short Current Address") : amended]
class  MSNdis_FddiShortCurrentAddress : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The short address the NIC is currently using.") : amended,
                WmiDataId(1)]    MSNdis_NetworkShortAddress     NdisCurrentAddress;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403b-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Short Multicast List") : amended]
class  MSNdis_FddiShortMulticastList : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of multicast short addresses enabled on the NIC.") : amended,
                WmiDataId(1)] uint32 NumberElements;
    [read,
                Description("The multicast short address list on the NIC enabled for packet reception.") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberElements")]    MSNdis_NetworkShortAddress NdisMulticastList[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403c-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Short Maximum List Size") : amended]
class  MSNdis_FddiShortMaximumListSize : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The maximum number of multicast short addresses the NIC driver can manage.") : amended,
                WmiDataId(1)]    uint32    NdisFddiShortMaximumListSize;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403d-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Attachment Type") : amended]
class  MSNdis_FddiAttachmentType : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Defines the attachment of the NIC to the network.") : amended,
                Values{"NdisFddiTypeIsolated",
                        "NdisFddiTypeLocalA",
                        "NdisFddiTypeLocalB",
                        "NdisFddiTypeLocalAB",
                        "NdisFddiTypeLocalS",
                        "NdisFddiTypeWrapA",
                        "NdisFddiTypeWrapB",
                        "NdisFddiTypeWrapAB",
                        "NdisFddiTypeWrapS",
                        "NdisFddiTypeCWrapA",
                        "NdisFddiTypeCWrapB",
                        "NdisFddiTypeCWrapS",
                        "NdisFddiTypeThrough"} : amended,
                ValueMap{"1",
                        "2",
                        "3",
                        "4",
                        "5",
                        "6",
                        "7",
                        "8",
                        "9",
                        "10",
                        "11",
                        "12",
                        "13"},
                WmiDataId(1)]    uint32    NdisFddiAttachmentType;

//
//      This can be of the following type:
//
//              typedef enum _NDIS_FDDI_ATTACHMENT_TYPE
//          {
//              NdisFddiTypeIsolated = 1,
//              NdisFddiTypeLocalA,
//              NdisFddiTypeLocalB,
//              NdisFddiTypeLocalAB,
//              NdisFddiTypeLocalS,
//              NdisFddiTypeWrapA,
//              NdisFddiTypeWrapB,
//              NdisFddiTypeWrapAB,
//              NdisFddiTypeWrapS,
//              NdisFddiTypeCWrapA,
//              NdisFddiTypeCWrapB,
//              NdisFddiTypeCWrapS,
//              NdisFddiTypeThrough
//          } NDIS_FDDI_ATTACHMENT_TYPE, *PNDIS_FDDI_ATTACHMENT_TYPE;
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403e-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Upstream Node Long") : amended]
class  MSNdis_FddiUpstreamNodeLong : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The long address of the station above this NIC on the ring or zero if the address is unknown.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress  NdisFddiUpstreamNodeLong;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403f-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Downstream Node Long") : amended]
class  MSNdis_FddiDownstreamNodeLong : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The long address of the station below this NIC on the ring or zero if the address is unknown.") : amended,
                WmiDataId(1)]    MSNdis_NetworkAddress  NdisFddiDownstreamNodeLong;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14040-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Frame Errors") : amended]
class  MSNdis_FddiFrameErrors : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The number of frames detected in error by this NIC that have not been detected in error by another device on the ring.") : amended,
                WmiDataId(1)]    uint32    NdisFddiFrameErrors;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14041-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Frames Lost") : amended]
class  MSNdis_FddiFramesLost : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The number of times this NIC detected a format error during frame reception such that the frame was stripped.") : amended,
                WmiDataId(1)]    uint32    NdisFddiFramesLost;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14042-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI Ring Management State") : amended]
class  MSNdis_FddiRingManagmentState : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Defines the current state of the Ring Management state machine.") : amended,
                Values{"NdisFddiRingIsolated",
                        "NdisFddiRingNonOperational",
                        "NdisFddiRingOperational",
                        "NdisFddiRingDetect",
                        "NdisFddiRingNonOperationalDup",
                        "NdisFddiRingOperationalDup",
                        "NdisFddiRingDirected",
                        "NdisFddiRingTrace"} : amended,
                ValueMap{"1",
                        "2",
                        "3",
                        "4",
                        "5",
                        "6",
                        "7",
                        "8"},
                WmiDataId(1)]    uint32    NdisFddiRingManagmentState;

//
//      This can be of the following type:
//
//              typedef enum _NDIS_FDDI_RING_MGT_STATE
//      {
//          NdisFddiRingIsolated = 1,
//          NdisFddiRingNonOperational,
//          NdisFddiRingOperational,
//          NdisFddiRingDetect,
//          NdisFddiRingNonOperationalDup,
//          NdisFddiRingOperationalDup,
//          NdisFddiRingDirected,
//          NdisFddiRingTrace
//      } NDIS_FDDI_RING_MGT_STATE, *PNDIS_FDDI_RING_MGT_STATE;
//
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14043-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI LCT Failures") : amended]
class  MSNdis_FddiLctFailures : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The count of the consecutive times the link confidence test (LCT) has failed during connection management.") : amended,
                WmiDataId(1)]    uint32    NdisFddiLctFailures;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14044-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI LEM Rejects") : amended]
class  MSNdis_FddiLemRejects : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The link error monitor (LEM) count of times that a link was rejected.") : amended,
                WmiDataId(1)]    uint32    NdisFddiLemRejects;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{acf14045-a61c-11d0-8dd4-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS FDDI LConnect State") : amended]
class  MSNdis_FddiLConnectionState : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Defines the state of this port's Physical Connection Management (PCM) state machine.") : amended,
                Values{"NdisFddiStateOff",
                        "NdisFddiStateBreak",
                        "NdisFddiStateTrace",
                        "NdisFddiStateConnect",
                        "NdisFddiStateNext",
                        "NdisFddiStateSignal",
                        "NdisFddiStateJoin",
                        "NdisFddiStateVerify",
                        "NdisFddiStateActive",
                        "NdisFddiStateMaintenance"} : amended,
                ValueMap{"1",
                        "2",
                        "3",
                        "4",
                        "5",
                        "6",
                        "7",
                        "8",
                        "9",
                        "10"},
                WmiDataId(1)]    uint32    NdisFddiLConnectionState;
//
//      This can be of the following type:
//
//              typedef enum _NDIS_FDDI_LCONNECTION_STATE
//      {
//          NdisFddiStateOff = 1,
//          NdisFddiStateBreak,
//          NdisFddiStateTrace,
//          NdisFddiStateConnect,
//          NdisFddiStateNext,
//          NdisFddiStateSignal,
//          NdisFddiStateJoin,
//          NdisFddiStateVerify,
//          NdisFddiStateActive,
//          NdisFddiStateMaintenance
//      } NDIS_FDDI_LCONNECTION_STATE, *PNDIS_FDDI_LCONNECTION_STATE;
//

};


///
///
///     Wireless (802.11) specific GUIDs
///

///
///     OID_802_11_BSSID:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{2504b6c2-1fa5-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Base Service Set Identifier: the MAC address of the associated access point. Writing this is useful when doing a site survey.") : amended]
class  MSNdis_80211_BaseServiceSetIdentifier : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 access point MAC address.") : amended,
                WmiDataId(1)]   uint8       Ndis80211MacAddress[6];
};


///
///     OID_802_11_SSID:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{7d2a90ea-2041-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Service Set Identifier string that identifies a set of interconnected basic service sets. This is a NULL terminated ANSI string upto 32 characters long.") : amended]
class  MSNdis_80211_ServiceSetIdentifier : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("SSID string") : amended,
                WmiDataId(1)]   uint8       Ndis80211SsId[33];
};


///
///     Embedded class definition for _NDIS_802_11_NETWORK_TYPE.
///
[WMI, guid("{e779ab61-b9ab-11d4-b675-002048570337}")]
class  MSNdis_80211_NetworkType : MSNdis
{
    [
                Description("NDIS 802.11 network type") : amended,
                Values{"Ndis802_11FH",
                       "Ndis802_11DS"} : amended,
                ValueMap{"0",
                         "1"},
                WmiDataId(1)]      uint32      Ndis80211NetworkType;
};

///
///     OID_802_11_NETWORK_TYPES_SUPPORTED:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{8531d6e6-2041-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 supported network types") : amended]
class  MSNdis_80211_NetworkTypesSupported : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of items in list of 802.11 network types") : amended,
                WmiDataId(1)]   uint32      NumberOfItems;
    [
    read,
                Description("List of NDIS 802.11 network types") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberOfItems")]
                                MSNdis_80211_NetworkType    Ndis80211NetworkTypes[];
};


///
///     OID_802_11_NETWORK_TYPE_IN_USE:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{857e2326-2041-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 network type in use determines whether the station uses Frequency Hopping Spread Spectrum or Direct Sequence Spread Spectrum.") : amended]
class  MSNdis_80211_NetworkTypeInUse : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 network type") : amended,
                WmiDataId(1)]
                                MSNdis_80211_NetworkType    Ndis80211NetworkTypeInUse;
};


///
///     OID_802_11_POWER_MODE:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{85be837c-2041-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Power Mode") : amended]
class  MSNdis_80211_PowerMode : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The current 802.11 power mode") : amended,
                Values{"Ndis802_11PowerModeCAM",
                       "Ndis802_11PowerModeMAX_PSP",
                       "Ndis802_11PowerModeFast_PSP"} : amended,
                ValueMap{"0",
                         "1",
                         "2"},
                WmiDataId(1)]   uint32      Ndis80211PowerMode;
};


///
///     OID_802_11_TX_POWER_LEVEL:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{11e6ba76-2053-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Transmit power level") : amended]
class  MSNdis_80211_TransmitPowerLevel : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 transmit power level in mW") : amended,
                WmiDataId(1)]   uint32      Ndis80211TransmitPowerLevel;
};


///
///     OID_802_11_RSSI:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{1507db16-2053-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Received Signal Strength Indication") : amended]
class  MSNdis_80211_ReceivedSignalStrength : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The 802.11 received signal strength in dBm") : amended,
                WmiDataId(1)]   sint32      Ndis80211ReceivedSignalStrength;
};


///
///     OID_802_11_RSSI_TRIGGER:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{155689b8-2053-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Received Signal Strength Indication event trigger. An event of class MSNdis_80211_ReceivedSignalStrengthEvent is generated when the current RSSI goes past the trigger value.") : amended]
class  MSNdis_80211_ReceivedSignalStrengthEventTrigger : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 RSSI trigger value in dBm") : amended,
                WmiDataId(1)]   sint32      Ndis80211ReceivedSignalStrengthTrigger;
};


///
///     Embedded class definition for _NDIS_802_11_NETWORK_INFRASTRUCTURE.
///
[WMI, guid("{34e1fa48-b9b6-11d4-b675-002048570337}")]
class  MSNdis_80211_NetworkInfrastructure : MSNdis
{
    [
                Description("The 802.11 infrastructure mode") : amended,
                Values{"Ndis802_11IBSS",
                       "Ndis802_11Infrastructure",
                       "Ndis802_11AutoUnknown"},
                ValueMap{"0",
                         "1",
                         "2"},
                WmiDataId(1)]      uint32  Ndis80211NetworkInfrastructure;
};


///
///
///     Embedded class definition for _NDIS_802_11_CONFIGURATION_FH.
///     This is used with MSNdis_80211_Configuration (below).
///
///
[WMI, guid("{4a800b8c-2068-11d4-97eb-00c04f79c403}")]
class  MSNdis_80211_ConfigurationFH : MSNdis
{
    [
                WmiDataId(1)]       uint32  FHLength;
    [
                WmiDataId(2)]       uint32  HopPattern;
    [
                WmiDataId(3)]       uint32  HopSet;
    [
                WmiDataId(4)]       uint32  DwellTime;
};


///
///
///     Embedded class definition for _NDIS_802_11_CONFIGURATION. This
///     is used with OID_802_11_CONFIGURATION and OID_802_11_BSSID_LIST.
///
///
[WMI, guid("{220c16fc-b9a8-11d4-b675-002048570337}")]
class  MSNdis_80211_ConfigurationInfo : MSNdis
{
    [
                Description("Length of configuration structure") : amended,
                WmiDataId(1)]       uint32  ConfigLength;
    [
                Description("Beacon period in Kusec") : amended,
                WmiDataId(2)]       uint32  BeaconPeriod;
    [
                Description("Announcement Traffic Indication Message (ATIM) Window in Kusec") : amended,
                WmiDataId(3)]       uint32  ATIMWindow;
    [
                Description("Frequency in kHz") : amended,
                WmiDataId(4)]       uint32  DSConfig;
    [
                Description("Radio configuration parameters") : amended,
                WmiDataId(5)]       MSNdis_80211_ConfigurationFH      FHConfig;
};


///
///
///     Embedded class definition for _NDIS_WLAN_BSSID. This is used in
///     OID_802_11_BSSID_LIST (below).
///
///
[WMI, guid("{6929e718-2062-11d4-97eb-00c04f79c403}")]
class  MSNdis_80211_WLanBssId : MSNdis
{
    [
                WmiDataId(1)]       uint32  Ndis80211WLanBssIdLength;
    [
                WmiDataId(2)]       uint8   Ndis80211MacAddress[6];
    [
                WmiDataId(3)]       uint16  Reserved;
    [
                WmiDataId(4)]       uint32  Ndis80211SsIdLength;
    [
                WmiDataId(5)]       uint8   Ndis80211SsId[32];
    [
                WmiDataId(6)]       uint32  Ndis80211Privacy;
    [
                WmiDataId(7)]       uint32  Ndis80211Rssi;
    [
                WmiDataId(8)]       MSNdis_80211_NetworkType    Ndis80211NetworkTypeInUse;
    [
                WmiDataId(9)]       MSNdis_80211_ConfigurationInfo  Ndis80211Configuration;
    [
                WmiDataId(10)]      MSNdis_80211_NetworkInfrastructure  Ndis80211InfrastructureMode;
    [
                WmiDataId(11)]      uint8   Ndis80211SupportedRate[8];
};


///
///     OID_802_11_BSSID_LIST:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{69526f9a-2062-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Base Service Set Identifier list. This is a list of all BSSID in range, their SSID and RSSI.") : amended]
class  MSNdis_80211_BSSIList : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of items in list of 802.11 BSSI") : amended,
                WmiDataId(1)]   uint32      NumberOfItems;
    [
    read,
                Description("The list of in-range BSSIDs and their properties") : amended,
                WmiDataId(2),
                WmiSizeIs("NumberOfItems")]
                                MSNdis_80211_WLanBssId  Ndis80211BSSIList[];
};


///
///     OID_802_11_INFRASTRUCTURE_MODE:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{697d5a7e-2062-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Infrastructure mode - defines how the device connects to the network.") : amended]
class  MSNdis_80211_InfrastructureMode : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                WmiDataId(1)]   MSNdis_80211_NetworkInfrastructure   Ndis80211InfrastructureMode;
};


///
///     OID_802_11_FRAGMENTATION_THRESHOLD:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{69aaa7c4-2062-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("The size beyond which the 802.11 device should fragment packets") : amended]
class  MSNdis_80211_FragmentationThreshold : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 fragmentation threshold in bytes") : amended,
                WmiDataId(1)]   uint32      Ndis80211FragmentationThreshold;
};



///
///     OID_802_11_RTS_THRESHOLD:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{0134d07e-2064-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("The size beyond which the 802.11 device should invoke the RTS/CTS mechanism") : amended]
class  MSNdis_80211_RTSThreshold : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The 802.11 RTS threshold, in bytes") : amended,
                WmiDataId(1)]   uint32      Ndis80211RTSThreshold;
};


///
///     OID_802_11_NUMBER_OF_ANTENNAS:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{01779336-2064-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("The number of antennas on the 802.11 radio.") : amended]
class  MSNdis_80211_NumberOfAntennas : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("The number of antennas") : amended,
                WmiDataId(1)]   uint32      Ndis80211NumberOfAntennas;
};


///
///     OID_802_11_RX_ANTENNA_SELECTED:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{01ac07a2-2064-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("The antenna selected for receiving on the radio of the 802.11 device") : amended]
class  MSNdis_80211_ReceiveAntennaSelected : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The receive antenna number") : amended,
                WmiDataId(1)]   uint32      Ndis80211ReceiveAntennaSelected;
};



///
///     OID_802_11_TX_ANTENNA_SELECTED:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{01dbb74a-2064-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("The antenna selected for transmitting on the radio of the 802.11 device") : amended]
class  MSNdis_80211_TransmitAntennaSelected : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("The transmit antenna number") : amended,
                WmiDataId(1)]   uint32      Ndis80211TransmitAntennaSelected;
};


///
///     OID_802_11_SUPPORTED_RATES
///
[WMI, Dynamic, Provider("WMIProv"), guid("{49db8722-2068-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("A set of supported NDIS 802.11 data rates in the operational rate set that the radio is capable of running at.") : amended]
class  MSNdis_80211_DataRates : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
    [
    read,
                Description("The list of data rates, in units of 0.5 Mbps") : amended,
                WmiDataId(1)]   uint8       Ndis80211DataRate[8];
};


///
///     OID_802_11_DESIRED_RATES:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{452ee08e-2536-11d4-97ed-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 data rates that are desirable for the radio to operate in.") : amended]
class  MSNdis_80211_DesiredDataRates : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
    [
    read, write,
                Description("The list of desired data rates, in units of 0.5 Mbps") : amended,
                WmiDataId(1)]   uint8       Ndis80211DesiredRate[8];
};

///
///     OID_802_11_CONFIGURATION:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{4a4df982-2068-11d4-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 device radio configuration parameters") : amended]
class  MSNdis_80211_Configuration : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                WmiDataId(1)]   MSNdis_80211_ConfigurationInfo      Ndis80211Config;
};


///
///     OID_802_11_STATISTICS:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{42bb73b0-2129-11d4-97ec-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 device statistics") : amended]
class  MSNdis_80211_Statistics : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Length of the statistics structure") : amended,
                WmiDataId(1)]   uint32      StatisticsLength;
    [
    read,
                Description("Number of transmitted fragments") : amended,
                WmiDataId(2)]   uint64      TransmittedFragmentCount;
    [
    read,
                Description("Number of transmitted multicast frames") : amended,
                WmiDataId(3)]   uint64      MulticastTransmittedFrameCount;
    [
    read,
                Description("Number of failures") : amended,
                WmiDataId(4)]   uint64      FailedCount;
    [
    read,
                Description("Number of retries") : amended,
                WmiDataId(5)]   uint64      RetryCount;
    [
    read,
                Description("Number of multiple retries") : amended,
                WmiDataId(6)]   uint64      MultipleRetryCount;
    [
    read,
                Description("Number of Request To Send success") : amended,
                WmiDataId(7)]   uint64      RTSSuccessCount;
    [
    read,
                Description("Number of Request To Send failures") : amended,
                WmiDataId(8)]   uint64      RTSFailureCount;
    [
    read,
                Description("Number of Acknowledgement failures") : amended,
                WmiDataId(9)]   uint64      ACKFailureCount;
    [
    read,
                Description("Number of duplicate frames") : amended,
                WmiDataId(10)]   uint64      FrameDuplicateCount;
    [
    read,
                Description("Number of received fragments") : amended,
                WmiDataId(11)]   uint64      ReceivedFragmentCount;
    [
    read,
                Description("Number of received multicast frames") : amended,
                WmiDataId(12)]   uint64      MulticastReceivedFrameCount;
    [
    read,
                Description("Number of frame checksum errors") : amended,
                WmiDataId(13)]   uint64      FCSErrorCount;
};


///
///     OID_802_11_ADD_WEP:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{4307bff0-2129-11d4-97ec-00c04f79c403}"),

 WmiExpense(1),
 Description("Set a WEP key to the NDIS 802.11 device") : amended]
class  MSNdis_80211_AddWEP : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    write,
                Description("Length of 802.11 WEP structure") : amended,
                WmiDataId(1)]   uint32      Length;
    [
    write,
                Description("WEP key index") : amended,
                WmiDataId(2)]   uint32      KeyIndex;
    [
    write,
                Description("WEP key length in bytes") : amended,
                WmiDataId(3)]   uint32      KeyLength;
    [
    write,
                Description("WEP key index") : amended,
                WmiDataId(4), WmiSizeIs("KeyLength")]
                                uint32      KeyMaterial[];
};


///
///     OID_802_11_REMOVE_WEP:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{433c345c-2129-11d4-97ec-00c04f79c403}"),

 WmiExpense(1),
 Description("Remove a WEP key on the NDIS 802.11 device") : amended]
class  MSNdis_80211_RemoveWEP : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    write,
                Description("The NDIS 802.11 WEP key index") : amended,
                WmiDataId(1)]   uint32      Ndis80211KeyIndex;
};


///
///     OID_802_11_DISASSOCIATE:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{43671f40-2129-11d4-97ec-00c04f79c403}"),

 WmiExpense(1),
 Description("Disassociate the NDIS 802.11 device with the current SSID") : amended]
class  MSNdis_80211_Disassociate : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
    [
    write,
                Description("Unused parameter") : amended,
                WmiDataId(1)]   uint32      UnusedParameter;
};


///
///     OID_802_11_BSSID_LIST_SCAN:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{0d9e01e1-ba70-11d4-b675-002048570337}"),

 WmiExpense(1),
 Description("Perform a survey to refresh the NDIS 802.11 BSS list") : amended]
class  MSNdis_80211_BssIdListScan : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
    [
    write,
                Description("Unused parameter") : amended,
                WmiDataId(1)]   uint32      UnusedParameter;
};



///
///     OID_802_11_AUTHENTICATION_MODE:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{43920a24-2129-11d4-97ec-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Authentication Mode") : amended]
class  MSNdis_80211_AuthenticationMode : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("NDIS 802.11 authentication mode setting") : amended,
                Values{"Ndis802_11AuthModeOpen",
                       "Ndis802_11AuthModeShared",
                       "Ndis802_11AuthModeAutoSwitch"},
                ValueMap{"0",
                         "1",
                         "2"},
                WmiDataId(1)]   uint32      Ndis80211AuthenticationMode;
};


///
///     OID_802_11_PRIVACY_FILTER:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{6733c4e9-4792-11d4-97f1-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Privacy Filter") : amended]
class  MSNdis_80211_PrivacyFilter : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("NDIS 802.11 privacy filter setting") : amended,
                Values{"Ndis802_11PrivFilterAcceptAll",
                       "Ndis802_11PrivFilter8021xWEP"},
                ValueMap{"0",
                         "1"},
                WmiDataId(1)]   uint32      Ndis80211PrivacyFilter;
};



///
///     OID_802_11_WEP_STATUS:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{b027a21f-3cfa-4125-800b-3f7a18fddcdc}"),

 WmiExpense(1),
 Description("NDIS 802.11 WEP Status") : amended]
class  MSNdis_80211_WEPStatus : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read, write,
                Description("NDIS 802.11 WEP Status setting") : amended,
                Values{"Ndis802_11WEPEnabled",
                       "Ndis802_11WEPDisabled",
                       "Ndis802_11WEPKeyAbsent",
                       "Ndis802_11WEPNotSupported"},
                ValueMap{"0",
                         "1",
                         "2",
                         "3"},
                WmiDataId(1)]   uint32      Ndis80211WEPStatus;
};


///
///     OID_802_11_RELOAD_DEFAULTS:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{748b14e8-32ee-4425-b91b-c9848c58b55a}"),

 WmiExpense(1),
 Description("NDIS 802.11 Reload Default Settings") : amended]
class  MSNdis_80211_ReloadDefaults : MSNdis
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    write,
                Description("The parameter(s) to be reloaded to default settings") : amended,
                Values{"Ndis802_11ReloadWEPKeys"} : amended,
                ValueMap{"0"},
                WmiDataId(1)]   uint32      Ndis80211ReloadDefaults;
};


///
///
///     NDIS status specific GUIDs
///
///


[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d76-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Reset Start") : amended]
class  MSNdis_StatusResetStart : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d77-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Reset End") : amended]
class  MSNdis_StatusResetEnd  : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d7d-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Media Connect") : amended]
class  MSNdis_StatusMediaConnect : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d7e-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Media Disconnect") : amended]
class  MSNdis_StatusMediaDisconnect : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d84-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Media Specific Indication") : amended]
class  MSNdis_StatusMediaSpecificIndication  : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("Number of bytes for media specific status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Media specific status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusMediaSpecificIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d85-b1f3-11d0-8dd7-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Status Link Speed Change") : amended]
class  MSNdis_StatusLinkSpeedChange  : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
                Description("New inbound and outbound link speeds for the adapter.") : amended,
                WmiDataId(1)]    MSNdis_NetworkLinkSpeed        NdisStatusLinkSpeedChange;
};

[WMI, Dynamic, Provider("WMIProv"), 
 guid("{5413531c-b1f3-11d0-d78d-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Protocol Bind Notification") : amended]
class  MSNdis_StatusProtocolBind  : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
     Description("Name of transport bound") : amended,
     WmiDataId(1)]    string Transport;
};

[WMI, Dynamic, Provider("WMIProv"), 
 guid("{6e3ce1ec-b1f3-11d0-d78d-00c04fc3358c}"),

 WmiExpense(1),
 Description("NDIS Protocol Unbind Notification") : amended]
class  MSNdis_StatusProtocolUnbind  : WMIEvent
{
        [key, read]
        string          InstanceName;
        
        [read]
        boolean         Active;
        
    [
    read,
     Description("Name of transport unbound") : amended,
     WmiDataId(1)]    string Transport;
};

//
// Keyboard and Mouse

[abstract]
class MSKeyboard
{
};

class MSMouse
{
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Keyboard port driver information") : amended,
 guid("{4731F89A-71CB-11d1-A52C-00A0C9062910}"),
 GuidName1("KEYBOARD_PORT_WMI_STD_DATA_GUID"),
 HeaderName("KEYBOARD_PORT_WMI_STD_DATA"),
 DisplayName("Keyboard Port Information") : amended
 ]
class MSKeyboard_PortInformation : MSKeyboard
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Connector Type") : amended,
    WmiDataId(1),
     read,
     Values{"I8042 Connector"
             "Serial Connector",
             "USB Connector" } : amended,
     ValueMap{"0",
             "1",
             "2" },
     DefineValues{"KEYBOARD_PORT_WMI_STD_I8042",
                  "KEYBOARD_PORT_WMI_STD_SERIAL",
                  "KEYBOARD_PORT_WMI_STD_USB"},
     Description("How the keyboard is connected to the computer") : amended]
    uint32 ConnectorType;

    [DisplayName("Data Queue Size") : amended,
    WmiDataId(2),
     read,
     Description("The DataQueueSize property indicates the size of the data queue.") : amended]
    uint32   DataQueueSize;

    [DisplayName("Error Count") : amended,
    WmiDataId(3),
     read,
     Description("Number of errors that occured on this device") : amended]
    uint32 ErrorCount;

    [DisplayName("Number of Function Keys") : amended,
    WmiDataId(4),
     read,
     Description("The NumberOfFunctionKeys property indicates the number of function keys on the keyboard.") : amended]
    uint32   FunctionKeys;

    [DisplayName("Number of Indicators") : amended,
    WmiDataId(5),
     read,
     Description("The NumberOfIndicators property indicates the number of indicator leds on the keyboard.") : amended]
    uint32   Indicators;
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Keyboard port extended ID") : amended,
 guid("{6ac4e23d-a950-4518-8b2b-aa4dcd5fe14a}"),
 GuidName1("KEYBOARD_PORT_WMI_EXTENDED_ID"),
 HeaderName("KEYBOARD_ID_EX"),
 DisplayName("Keyboard Extended ID Information") : amended
 ]
class MSKeyboard_ExtendedID : MSKeyboard
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Extended Type") : amended,
    WmiDataId(1),
     read,
     Description("The Extended Type property indicates a 32 bit type identifier for the keyboard.") : amended]
    uint32   Type;

    [DisplayName("Extended Subtype") : amended,
    WmiDataId(2),
     read,
     Description("The Extended Type property indicates a 32 bit subtype identifier for the keyboard.") : amended]
    uint32   Subtype;
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Mouse port driver information") : amended,
 guid("{4731F89C-71CB-11d1-A52C-00A0C9062910}"),
 GuidName1("POINTER_PORT_WMI_STD_DATA_GUID"),
 HeaderName("POINTER_PORT_WMI_STD_DATA"),
 DisplayName("Mouse Port Information") : amended
 ]
class MSMouse_PortInformation : MSMouse
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Connector Type") : amended,
    WmiDataId(1),
     read,
     Values{"I8042 Connector"
             "Serial Connector",
             "USB Connector" } : amended,
     ValueMap{"0",
             "1",
             "2" },
     DefineValues{"POINTER_PORT_WMI_STD_I8042",
                  "POINTER_PORT_WMI_STD_SERIAL",
                  "POINTER_PORT_WMI_STD_USB"},
     Description("How the mouse is connected to the computer") : amended]
    uint32 ConnectorType;

    [DisplayName("Data Queue Size") : amended,
    WmiDataId(2),
     read,
     Description("The DataQueueSize property indicates the size of the data queue.") : amended]
    uint32   DataQueueSize;

    [DisplayName("Error Count") : amended,
    WmiDataId(3),
     read,
     Description("Number of errors that occured on this device") : amended]
    uint32   ErrorCount;

    [DisplayName("Number of Buttons") : amended,
    WmiDataId(4),
     read,
     Description("The NumberOfButtons property indicates the number of buttons on the pointing device.") : amended]
    uint32   Buttons;

    [DisplayName("Hardware Type") : amended,
    WmiDataId(5),
     read,
     Values{"Standard Mouse",
          "Standard Pointer",
          "Standard Absolute Pointer",
          "Tablet",
          "Touch Screen",
          "Pen",
          "Track Ball",
          "Other"} : amended,
     ValueMap{"0",
          "1",
          "2",
          "3",
          "4",
          "5",
          "6",
          "256"},
     DefineValues{"POINTER_PORT_WMI_STD_MOUSE",
                  "POINTER_PORT_WMI_STD_POINTER",
                  "POINTER_PORT_WMI_ABSOLUTE_POINTER",
                  "POINTER_PORT_WMI_TABLET",
                  "POINTER_PORT_WMI_TOUCH_SCRENE",
                  "POINTER_PORT_WMI_PEN",
                  "POINTER_PORT_WMI_TRACK_BALL",
                  "POINTER_PORT_WMI_OTHER"},
     Description("The HardwareType property indicates the hardware type of the pointing device.") : amended]
    uint32 HardwareType;

};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Mouse class driver information") : amended,
 guid("{4731F89B-71CB-11d1-A52C-00A0C9062910}")
 ]
class MSMouse_ClassInformation : MSMouse
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [
    WmiDataId(1),
     read,
     Description("An identification number for the device") : amended]
    uint64   DeviceId;
};


[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Keyboard class driver information") : amended,
 guid("{4731F899-71CB-11d1-A52C-00A0C9062910}")
 ]
class MSKeyboard_ClassInformation : MSKeyboard
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [
    WmiDataId(1),
     read,
     Description("An identification number for the device") : amended]
    uint64   DeviceId;
};

//
// Thermal information via ACPI
[abstract]
class MSAcpi
{
}; 


[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("ThermalZone temperature information") : amended,
 guid("{A1BC18C0-A7C8-11d1-BF3C-00A0C9062910}"),
 DisplayName("Thermal Zone Information") : amended
 ]
class MSAcpi_ThermalZoneTemperature : MSAcpi
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Thermal Stamp") : amended,
    WmiDataId(1), 
     Description("Thermal information change stamp") : amended,
     read] 
    uint32 ThermalStamp;

    [DisplayName("Thermal Constant 1") : amended,
    WmiDataId(2), 
     Description("First thermal constant") : amended,
     read] 
    uint32 ThermalConstant1;

    [DisplayName("Thermal Constant 2") : amended,
    WmiDataId(3), 
     Description("Second thermal constant") : amended,
     read] 
    uint32 ThermalConstant2;

    [DisplayName("Reserved") : amended,
    WmiDataId(4), 
     Description("Reserved") : amended,
     read] 
    uint32 Reserved;

    [DisplayName("Sampling Period") : amended,
    WmiDataId(5), 
     Description("Sampling period") : amended,
     read] 
    uint32 SamplingPeriod;

    [DisplayName("Current Temperature") : amended,
    WmiDataId(6), 
     Description("Temperature at thermal zone in tenths of degrees Kelvin") : amended,
     read] 
    uint32 CurrentTemperature;

    [DisplayName("Passive Trippoint") : amended,
    WmiDataId(7), 
     Description("Temperature (in tenths of degrees Kelvin) at which the OS must activate CPU throttling (ie, enable passive cooling)") : amended,
     read] 
    uint32 PassiveTripPoint;

    [DisplayName("Critical Trippoint") : amended,
    WmiDataId(8), 
     Description("Temperature (in tenths of degrees Kelvin) at which the OS must shutdown the system (ie, critical temperature)") : amended,
     read] 
    uint32 CriticalTripPoint;

    [DisplayName("Active Trippoint Count") : amended,
    WmiDataId(9), 
     Description("Count of active trip points") : amended,
     read] 
    uint32 ActiveTripPointCount;

    [WmiDataId(10), 
     Description("Temperature levels (in tenths of degrees Kelvin) at which the OS must activate active cooling") : amended,
     DisplayName("Active Trippoint") : amended,
     MissingValue(0),
     read] 
    uint32 ActiveTripPoint[10];

};

//
// Disk
[abstract]
class MSDiskDriver
{
}; 

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Disk Geometry") : amended,
 guid("{25007F51-57C2-11d1-A528-00A0C9062910}"),
 HeaderName("WMI_DISK_GEOMETRY"),
 DisplayName("Disk Geometry") : amended
 ]
class MSDiskDriver_Geometry : MSDiskDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Cylinders") : amended,
    WmiDataId(1), 
     read] 
    sint64 Cylinders;

    [DisplayName("Media Type") : amended,
    WmiDataId(2), 
     Values{"Format is unknown",
             "5.25, 1.2MB,  512 bytes/sector",
             "3.5,  1.44MB, 512 bytes/sector",
             "3.5,  2.88MB, 512 bytes/sector",
             "3.5,  20.8MB, 512 bytes/sector",
             "3.5,  720KB,  512 bytes/sector",
             "5.25, 360KB,  512 bytes/sector",
             "5.25, 320KB,  512 bytes/sector",
             "5.25, 320KB,  1024 bytes/sector",
             "5.25, 180KB,  512 bytes/sector",
             "5.25, 160KB,  512 bytes/sector",
             "Removable media other than floppy",
             "Fixed hard disk media",
             "3.5, 120M Floppy",
             "3.5 ,  640KB,  512 bytes/sector",
             "5.25,  640KB,  512 bytes/sector",
             "5.25,  720KB,  512 bytes/sector",
             "3.5 ,  1.2Mb,  512 bytes/sector",
             "3.5 ,  1.23Mb, 1024 bytes/sector",
             "5.25,  1.23MB, 1024 bytes/sector",
             "3.5 MO 128Mb   512 bytes/sector",
             "3.5 MO 230Mb   512 bytes/sector",
             "8,     256KB,  128 bytes/sector"} : amended,
     ValueMap{"0",
             "1",
             "2",
             "3",
             "4",
             "5",
             "6",
             "7",
             "8",
             "9",
             "10",
             "11",
             "12",
             "13",
             "14",
             "15",
             "16",
             "17",
             "18",
             "19",
             "20",
             "21",
             "22"},
     read] 
    uint32 MediaType;

    [DisplayName("Tracks Per Cylinder") : amended,
    WmiDataId(3), 
     read] 
    uint32 TracksPerCylinder;

    [DisplayName("Sectors Per Track") : amended,
    WmiDataId(4), 
     read] 
    uint32 SectorsPerTrack;

    [DisplayName("Bytes Per Sector") : amended,
    WmiDataId(5), 
     read] 
    uint32 BytesPerSector;

};

[
 WMI, 
 Description("Disk performance statistics") : amended,
 guid("BDD865D2-D7C1-11d0-A501-00A0C9062910"),
 HeaderName("WMI_DISK_PERFORMANCE"),
 DisplayName("Disk Performance Information") : amended
 ]
class MSDiskDriver_PerformanceData : MSDiskDriver
{
    [DisplayName("Bytes Read") : amended,
    WmiDataId(1),
     Description("Number of bytes read on disk") : amended,
     read]
    sint64 BytesRead;

    [DisplayName("Bytes Written") : amended,
    WmiDataId(2),
     Description("Number of bytes written on disk") : amended,
     read]
    sint64 BytesWritten;

    [DisplayName("Read Time") : amended,
    WmiDataId(3),
     Description("Amount off time spent reading from disk") : amended,
     read]
    sint64 ReadTime;

    [DisplayName("Write Time") : amended,
    WmiDataId(4),
     Description("Amount off time spent writing to disk") : amended,
     read]
    sint64 WriteTime;

    [DisplayName("Idle Time") : amended,
    WmiDataId(5),
     Description("Amount off disk idle time") : amended,
     read]
    sint64 IdleTime;

    [DisplayName("Read Count") : amended,
    WmiDataId(6),
     Description("Number of read operations from disk") : amended,
     read]
    uint32 ReadCount;

    [DisplayName("Write Count") : amended,
    WmiDataId(7),
     Description("Number of write operations to disk") : amended,
     read]
    uint32 WriteCount;

    [DisplayName("Queue Depth") : amended,
    WmiDataId(8),
     Description("Number of requests waiting in the disk queue") : amended,
     read]
    uint32 QueueDepth;

    [DisplayName("Split Count") : amended,
    WmiDataId(9),
     Description("Number of split IO operations") : amended,
     read]
    uint32 SplitCount;

    [DisplayName("Query Time") : amended,
    WmiDataId(10),
     Description("") : amended,
     read]
    sint64 QueryTime;

    [DisplayName("Storage Device Number") : amended,
    WmiDataId(11),
     Description("") : amended,
     read]
    uint32 StorageDeviceNumber;

    [WmiDataId(12),
     DisplayName("Storage Manager Name") : amended,
     Description("") : amended,
     read]
    uint16 StorageManagerName[8];

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Disk performance statistics") : amended,
 guid("BDD865D1-D7C1-11d0-A501-00A0C9062910"),
 DisplayName("Disk Performance Information") : amended
 ]
class MSDiskDriver_Performance : MSDiskDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Performance Data") : amended,
    WmiDataId(1),
     Description("Performance Data Information") : amended,
     read]
    MSDiskDriver_PerformanceData PerfData;

    [DisplayName("Device Name") : amended,
    WmiDataId(2),
     Description("Internal device name") : amended,
     read]
    string DeviceName;
};



//
// General storage
[abstract]
class MSStorageDriver
{
}; 


[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Storage Device Failure Prediction Status") : amended,
 guid("{78ebc102-4cf9-11d2-ba4a-00a0c9062910}"),
 HeaderName("STORAGE_FAILURE_PREDICT_STATUS"),
 GuidName1("WMI_STORAGE_FAILURE_PREDICT_STATUS_GUID"),
 DisplayName("Failure Predict Status") : amended
 ]
class MSStorageDriver_FailurePredictStatus : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Reason") : amended,
    WmiDataId(1), 
     ValueMap{"0", "255"},
     Values{"Unknown", "Test - Not a failure"}  : amended,
     read] 
    uint32 Reason;


    [DisplayName("Predict Failure") : amended,
    WmiDataId(2), 
     Description("TRUE if drive is predictiing failure. In this case it is critical that the disk is backed up immediately") : amended,
     read]
    boolean PredictFailure;

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Storage Device Failure Prediction Data") : amended,
 guid("{78ebc103-4cf9-11d2-ba4a-00a0c9062910}"),
 HeaderName("STORAGE_FAILURE_PREDICT_DATA"),
 GuidName1("WMI_STORAGE_FAILURE_PREDICT_DATA_GUID"),
 DisplayName("Failure Predict Data") : amended
 ]
class MSStorageDriver_FailurePredictData : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Length") : amended,
    WmiDataId(1), 
     read] 
    uint32 Length;


    [DisplayName("Vendor Specific") : amended,
    WmiDataId(2), 
     Description("Vendor specific failure prediction data") : amended,
     read]
    uint8 VendorSpecific[512];

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("ATAPI SMART Data") : amended,
 guid("{78ebc103-4cf9-11d2-ba4a-00a0c9062910}"),
 HeaderName("ATAPI_FAILURE_PREDICT_DATA"),
 GuidName1("WMI_ATAPI_FAILURE_PREDICT_DATA_GUID"),
 read,
 DisplayName("ATAPI Failure Predict Data") : amended
 ]
class MSStorageDriver_ATAPISmartData : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Length") : amended,
    WmiDataId(1), 
     read] 
    uint32 Length;


    [DisplayName("Vendor Specific") : amended,
    WmiDataId(2), 
     Description("Vendor specific failure prediction data") : amended,
     read]
    uint8 VendorSpecific[362];

    [WmiDataId(3),
     Description("Off-line data collection status") : amended,
     read,
     Values{"0", "2", "4", "5", "6", "128", "130", "132", "133", "134"},
     ValueMap{"Off-line data collection activity was never started",
              "Off-line data collection activity was completed without error",
              "Off-line data collection activity was suspended by an interrupting command from host",
              "Off-line data collection activity was aborted by an interrupting command from host",
              "Off-line data collection activity was aborted by the device with a fatal error",
              "Off-line data collection activity was never started",
              "Off-line data collection activity was completed without error",
              "Off-line data collection activity was suspended by an interrupting command from host",
              "Off-line data collection activity was aborted by an interrupting command from host",
              "Off-line data collection activity was aborted by the device with a fatal error"
             } : amended
    ]
    uint8 OfflineCollectionStatus;

    [WmiDataId(4),
     Description("Self-test execution status byte") : amended,
     read,
     Values{"0", "1", "2", "3", "4", "5", "6", "7", "15"},
     ValueMap{
              "The previous self-test routine completed without error or no self-test has ever been run"
              "The self-test routine was aborted by the host",
              "The self-test routine was interrupted by the host with a hardware or software reset",
              "A fatal error or unknown test error occurred while the device was executing its self-test routineand the device was unable to complete the self-test routine.",
              "The previous self-test completed having a test element that failed and the test element that failed is not known.",
              "The previous self-test completed having the electrical element of the test failed.",
              "The previous self-test completed having the servo (and/or seek) test element of the test failed.",
              "The previous self-test completed having the read element of the test failed.",
              "Self-test routine in progress."
             } : amended
    ]
    uint8 SelfTestStatus;

    [WmiDataId(5),
     Description("Total time in seconds to complete off-line data collection activity") : amended,
     read
    ]
    uint16 TotalTime;

    [WmiDataId(6),
     Description("Vendor Specific") : amended,
     read
    ]
    uint8 VendorSpecific2;

    [WmiDataId(7),
     Description("Off-line data collection capability") : amended,
     BitMap{"0", "1", "2", "3", "4"},
     BitValues{
            "(EXECUTE OFF-LINE IMMEDIATE implemented bit) - If this bit is set to one, then the SMART EXECUTE OFF-LINE IMMEDIATE command is implemented by this device. If this bit is cleared to zero, then the SMART EXECUTE OFF-LINE IMMEDIATE command is not implemented by this device.",
            "(vendor specific)",
            "(abort/restart off-line by host bit) - If this bit is set to one, then the device shall abort all off-line data collection activity initiated by an SMART EXECUTE OFF-LINE IMMEDIATE command upon receipt of a new command within 2 seconds of receiving the new command. If this bit is cleared to zero, the device shall suspend off-line data collection activity after an interrupting command and resume off-line data collection activity after some vendor-specified event.",
            "(off-line read scanning implemented bit) - If this bit is cleared to zero, the device does not support off-line read scanning. If this bit is set to one, the device supports off-line read scanning.",
            "(self-test implemented bit) - If this bit is cleared to zero, the device does not implement the Short and Extended self-test routines. If this bit is set to one, the device implements the Short and Extended self-test routines."
           } : amended,
     read
    ]
    uint8 OfflineCollectCapability;

    [WmiDataId(8),
     Description("SMART capability") : amended,
     read,
     BitMap{"0", "1"},
     BitValues{
            "(power mode SMART data saving capability bit) - If this bit is set to one, the device saves SMART data prior to going into a power saving mode (Idle, Standby, or Sleep) or immediately upon return to Active or Idle mode from a Standby mode. If this bit is cleared to zero, the device does not save SMART data prior to going into a power saving mode (Idle, Standby, or Sleep) or immediately upon return to Active or Idle mode from a Standby mode.",
            "(SMART data autosave after event capability bit) - This bit is set to one for devices complying with this standard."
           } : amended
    ]
    uint16 SmartCapability;

    [WmiDataId(9),
     Description("Error logging capability") : amended,
     read,
     BitMap{"0"},
     BitValues{"Device error logging supported"} : amended
    ]
    uint8 ErrorLogCapability;

    [WmiDataId(10),
     Description("Vendor Specific") : amended,
     read
    ]
    uint8 VendorSpecific3;

    [WmiDataId(11),
     Description("Short self-test routine recommended polling time (in minutes)") : amended,
     read
    ]
    uint8 ShortPollTimeInMinutes;

    [WmiDataId(12),
     Description("Extended self-test routine recommended polling time (in minutes)") : amended,
     read
    ]
    uint8 ExtendedPollTimeInMinutes;

    [WmiDataId(13),
     Description("Reserved"),
     read
    ]
    uint8 Reserved[12];

    [WmiDataId(14),
     Description("Vendor Specific") : amended,
     read
    ]
    uint8 VendorSpecific4[125];

    [WmiDataId(15),
     Description("Data structure checksum") : amended,
     read
    ]
    uint8 Checksum;

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Storage Device Failure Prediction Thresholds") : amended,
 guid("{DAE10783-CC31-4d2a-8A0F-861C04077A95}"),
 HeaderName("STORAGE_FAILURE_PREDICT_THRESHOLDS"),
 GuidName1("WMI_STORAGE_FAILURE_PREDICT_THRESHOLDS_GUID"),
 DisplayName("Failure Predict Thresholds") : amended
 ]
class MSStorageDriver_FailurePredictThresholds : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Vendor Specific") : amended,
    WmiDataId(1), 
     Description("Vendor specific failure prediction thresholds") : amended,
     read]
    uint8 VendorSpecific[512];

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Storage Device Failure Prediction Event") : amended,
 guid("{78ebc104-4cf9-11d2-ba4a-00a0c9062910}"),
 HeaderName("STORAGE_FAILURE_PREDICT_EVENT"),
 GuidName1("WMI_STORAGE_PREDICT_FAILURE_EVENT_GUID"),
 DisplayName("Failure Predict Event") : amended
 ]
class MSStorageDriver_FailurePredictEvent : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Length") : amended,
    WmiDataId(1), 
     read] 
    uint32 Length;


    [DisplayName("Vendor Specific") : amended,
    WmiDataId(2), 
     Description("Vendor specific failure prediction data") : amended,
     WmiSizeIs("Length"),
     read]
    uint8 VendorSpecific[];

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Storage Device Failure Prediction Functions") : amended,
 guid("{78ebc105-4cf9-11d2-ba4a-00a0c9062910}"),
 HeaderName("STORAGE_FAILURE_PREDICT_FUNCTION"),
 GuidName1("WMI_STORAGE_FAILURE_PREDICT_FUNCTION_GUID"),
 DisplayName("Failure Predict Functions") : amended
 ]
class MSStorageDriver_FailurePredictFunction : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiMethodId(1), 
     Implemented,
     DisplayName("Allow Performance Degredation") : amended,
     HeaderName("ALLOW_PERFORMANCE_HIT"),
     Description("Configures setting that specifies if additional failure prediction checking can cause a loss of performance") : amended]
    void AllowPerformanceHit([in, DisplayName("Allow") : amended] boolean Allow);

    [WmiMethodId(2), 
     Implemented,
     DisplayName("Enable Or Disable Hardware Failure Prediction") : amended,
     HeaderName("ENABLE_DISABLE_FP"),
     Description("Enables or disables failure prediction checking at the hardware level") : amended]
    void EnableDisableHardwareFailurePrediction([in, DisplayName("Enable") : amended] boolean Enable);

    [WmiMethodId(3), 
     Implemented,
     DisplayName("Enable Or Disable Failure Prediction Polling") : amended,
     HeaderName("ENABLE_DISABLE_FP_POLLING"),
     Description("Enables or disables polling for failure prediction status") : amended]
    void EnableDisableFailurePredictionPolling(
                               [in, 
                                DisplayName("Period") : amended,
                                Description("Period in seconds to poll for failure prediction status") : amended]  
                                uint32 Period,
                               [in] boolean Enable);
    [WmiMethodId(4), 
     Implemented,
     DisplayName("Get Failure Prediction Capability") : amended,
     HeaderName("GET_FP_CAPABILITY"),
     Description("Returns mechanism used to read failure prediction status ") : amended]
    void GetFailurePredictionCapability([out, ValueMap{"0", "1", "2", "3"},
                                         Value{"Not Supported",
                                                  "Ioctl Based",
                                                  "IDE SMART",
                                                  "SCSI SMART"} : amended,
                                         DisplayName("Capability") : amended
                                        ] uint32 Capability);

    [WmiMethodId(5), 
     HeaderName("ENABLE_OFFLINE_DIAGS"),
     Implemented,     
     DisplayName("Enable Offline Diags") : amended,
     Description("Enables execution of offline diagnostics") : amended]
    void EnableOfflineDiags([out, DisplayName("Success") : amended] boolean Success);


    [WmiMethodId(6),
     Implemented,
     DisplayName("Read Log Sectors") : amended,
     HeaderName("READ_LOG_SECTORS"),
     Description("Read log sectors")  : amended
    ]
    void ReadLogSectors([in, DisplayName("Log Address") : amended] uint8 LogAddress,
                        [in, DisplayName("Sector Count") : amended] uint8 SectorCount,
                        [out, DisplayName("Length") : amended] uint32 Length,
                        [out, WmiSizeIs("Length"), DisplayName("Log Sectors") : amended] uint8 LogSectors[]
                       );

    [WmiMethodId(7),
     Implemented,
     HeaderName("WRITE_LOG_SECTORS"),
     DisplayName("WriteLogSectors") : amended,
     Description("Write log sectors") : amended
    ]
    void WriteLogSectors([in, DisplayName("LogAddress") : amended] uint8 LogAddress,
                        [in, DisplayName("SectorCount") : amended] uint8 SectorCount,
                        [in, DisplayName("Length") : amended] uint32 Length,
                        [in, WmiSizeIs("Length"), DisplayName("LogSectors") : amended] uint8 LogSectors[],
                        [out, DisplayName("Success") : amended] boolean Success
                       );

    [WmiMethodId(8),
     Implemented,
     HeaderName("EXECUTE_SELF_TEST"),
     DisplayName("Execute Self Test") : amended,
     Description("Execute Self Test")  : amended
    ]
    void ExecuteSelfTest([in, DisplayName("Sub Command") : amended] uint8 Subcommand,
                         [out, 
                          DisplayName("Return Code") : amended,
                          ValueMap{"0", "1", "2"},
                          Value{"Successful Completion",
                                   "Captive Mode Required",
                                   "Unsuccessful Completion"} : amended
                         ]
                         uint32 ReturnCode);
};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Data for Scsi Info Exceptions Mode Page") : amended,
 guid("{1101D829-167B-4ebf-ACAE-28CAB7C34802}"),
 HeaderName("STORAGE_SCSI_INFO_EXCEPTIONS"),
 GuidName1("WMI_STORAGE_SCSI_INFO_EXCEPTIONS_GUID"),
 DisplayName("Scsi Info Exceptions") : amended
 ]
class MSStorageDriver_ScsiInfoExceptions : MSStorageDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Page Savable") : amended,
    WmiDataId(1), 
     Description("The returned Parameter Savable bit of 1 indicates that page parameter data is savable.") : amended,
     read, write]
     boolean PageSavable;
    
    [DisplayName("Flags") : amended,
    WmiDataId(2), 
     Description("Bit flags: "
                 "Perf set to zero indicates that informational exception operations that are the cause of delays are acceptable. "
                 "DExcpt set to zero indicates information exception operations shall be enabled. "
                 "Test of one instructs the drive to create false drive failures. "
                 "LogErr bit of zero indicates that logging of informational exception conditions are vendor specific.") : amended,
     BitValues{"Perf", "DExcpt", "Test", "LogErr"} : amended,
     BitMap{"7", "3",      "2",     "0"},
     read, write]
     uint8 Flags;

    [DisplayName("Reporting Method") : amended,
    WmiDataId(3), 
     Description("The Method of Reporting Informational Exceptions (MRIE) indicates the methods that shall be used by the target to report information exception conditions.") : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6"},
     Values{"No Reporting", "Asynchronous Event Reporting", "Generate Unit Attention", "Conditionally Generate Recovered Error", "Unconditionally Generate Recovered Error", "Generate No Sense", "Report On Request"} : amended,
     read, write]
     uint8 MRIE;

    [
    WmiDataId(4), 
     Description("Buffer padding to 32 bits, do not use") : amended,
     read]
     uint8 Padding;

    [DisplayName("Interval Timer") : amended,
    WmiDataId(5), 
     Description("Period in 100ms increments for reproting that an information exception condition has occurred.") : amended,
     read, write]
     uint32 IntervalTimer;

    [DisplayName("Report Count") : amended,
    WmiDataId(6), 
     Description("Indicates the number of times to report an informational exception condition to the application client. A value of zero indications there is no limit.") : amended,
     read, write]
     uint32 ReportCount;
};


[abstract]
class MSIde
{
}; 

[Dynamic, Provider("WMIProv"), WMI, 
 Description("Scsi Address") : amended,
 guid("{53f5630f-b6bf-11d0-94f2-00a0c91efb8b}"),
 DisplayName("Ide Port Information") : amended
 ]
class MSIde_PortDeviceInfo : MSIde
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Bus") : amended,
    WmiDataId(1), 
     Description("Scsi Bus Number") : amended,
     read] 
    uint8 Bus;
    
    [DisplayName("Target") : amended,
    WmiDataId(2), 
     Description("Scsi Target ID") : amended,
     read] 
    uint8 Target;

    [DisplayName("Lun") : amended,
    WmiDataId(3), 
     Description("Scsi Lun") : amended,
     read] 
    uint8 Lun;
};



// Serial
[abstract]
class MSSerial
{
};


[WMI, Dynamic, Provider ("WMIProv"),
 guid("{A0EC11A8-B16C-11D1-BD98-00A0C906BE2D}"),
 GuidName1("SERIAL_PORT_WMI_NAME_GUID"),
 Description("Serial Port Name" ) : amended,
 DisplayName("Serial Port Name") : amended
]
class MSSerial_PortName : MSSerial
{
    boolean Active;
    [key]
      string InstanceName;

    [DisplayName("Port Name") : amended,
    WmiDataId(1),
     Description("Serial Port Name") : amended,
     read]
      string PortName;
};


[WMI, Dynamic, Provider ("WMIProv"),
 guid("{EDB16A62-B16C-11D1-BD98-00A0C906BE2D}"),
 GuidName1("SERIAL_PORT_WMI_COMM_GUID"),
 HeaderName("SERIAL_WMI_COMM_DATA"),
 Description("Serial Communications Information") : amended,
 DisplayName("Serial Comm Information") : amended
]
class MSSerial_CommInfo : MSSerial
{
    boolean Active;
    [key]
      string InstanceName;

    [DisplayName("Baud Rate") : amended,
    WmiDataId(1),
     Description("The BaudRate property indicates the baud rate for this serial port") : amended,
     read]
      uint32 BaudRate;

    [WmiDataId(2),
     DisplayName("Bits Per Byte") : amended,
     Description("The BitsPerByte property indicates the number of bits per byte for the serial port") : amended,
     read]
      uint32 BitsPerByte;     

    [DisplayName("Parity") : amended,
    WmiDataId(3),
     read,
     Description("The Parity property indicates the type of parity used") : amended,
     Values{"None",
             "Odd",
             "Even",
             "Space",
             "Mark"} : amended,
     ValueMap{"0",
             "1",
             "2",
             "3",
             "4"},
     DefineValues{"SERIAL_WMI_PARITY_NONE",
                  "SERIAL_WMI_PARITY_ODD",
                  "SERIAL_WMI_PARITY_EVEN",
                  "SERIAL_WMI_PARITY_SPACE",
                  "SERIAL_WMI_PARITY_MARK"}
      ]
      uint32 Parity;

    [DisplayName("Parity Check Enable") : amended,
    WmiDataId(4),
     Description("The ParityCheckEnabled property determines whether parity checking is enabled") : amended,
     read]
      boolean ParityCheckEnable;

    [DisplayName("Stop Bits") : amended,
    WmiDataId(5),
     read,
     Description("The StopBits property indicates the number of stop bits for the serial port") : amended,
     Values{"1",
             "1.5",
             "2"}  : amended,
     ValueMap{"0",
             "1",
             "2"},
     DefineValues{"SERIAL_WMI_STOP_1",
                  "SERIAL_WMI_STOP_1_5",
                  "SERIAL_WMI_STOP_2"}]
      uint32 StopBits;

    [DisplayName("Xoff Character") : amended,
    WmiDataId(6),
     Description("The XOffCharacter property indicates the XOff character for the serial port") : amended,
     read]
      uint32 XoffCharacter;

    [DisplayName("Xoff Xmit Threshold") : amended,
    WmiDataId(7),
     Description("The XOffXmitThreshold property indicates the XOff transmit threshold for the serial port") : amended,
     read]
      uint32 XoffXmitThreshold;

    [DisplayName("Xon Character") : amended,
    WmiDataId(8),
     Description("The XOnCharacter property indicates the XOn character") : amended,
     read]
      uint32 XonCharacter;

    [DisplayName("Xon Xmit Threshold") : amended,
    WmiDataId(9),
     Description("The XOnXMitThreshold property indicates the XOn transmit threshold") : amended,
     read]
      uint32 XonXmitThreshold;
      
    [DisplayName("Maximum Baud Rate") : amended,
    WmiDataId(10),
     Description("The MaximumBaudRate property indicates the maximum baud rate of the serial port") : amended,
     read]
      uint32 MaximumBaudRate;

    [DisplayName("Maximum Output Buffer Size") : amended,
    WmiDataId(11),
     Description("The MaximumOutputBufferSize property indicates the maximum output buffer size (in bytes)") : amended,
     read]
      uint32 MaximumOutputBufferSize;

    [DisplayName("Maximum Input Buffer Size") : amended,
    WmiDataId(12),
     Description("The MaximumInputBufferSize property indicates the maximum input buffer size (in bytes)") : amended,
     read]
      uint32 MaximumInputBufferSize;

    [DisplayName("Support 16Bit Mode") : amended,
    WmiDataId(13),
     Description("The Support16BitMode property determines whether 16-bit mode is supported on the Win32 serial port") : amended,
     read]
      boolean Support16BitMode;

    [DisplayName("Support DTRDSR") : amended,
    WmiDataId(14),
     Description("The SupportDTRDSR property determines whether Data Terminal Ready (DTR) and Data Set Ready (DSR) signals are supported on the Win32 serial port.") : amended,
     read]
      boolean SupportDTRDSR;

    [DisplayName("Support Interval Timeouts") : amended,
    WmiDataId(15),
     Description("The SupportIntervalTimeouts property determines whether interval timeouts are supported on the serial port") : amended,
     read]
      boolean SupportIntervalTimeouts;

    [DisplayName("Support Parity Check") : amended,
    WmiDataId(16),
     Description("The SupportParityCheck property determines whether parity checking is supported on the Win32 serial port") : amended,
     read]
      boolean SupportParityCheck;

    [DisplayName("Support RTSCTS") : amended,
    WmiDataId(17),
     Description("The SupportRTSCTS property determines whether Ready To Send (RTS) and Clear To Send (CTS) signals are supported on the serial port") : amended,
     read]
      boolean SupportRTSCTS;

    [DisplayName("Support Xon Xoff") : amended,
    WmiDataId(18),
     Description("The SupportXOnXOff property determines whether software flow control is supported on the serial port") : amended,
     read]
      boolean SupportXonXoff;

    [DisplayName("Settable Baud Rate") : amended,
    WmiDataId(19),
     Description("The SettableBaudRate property determines whether the baud rate can be set on the serial port") : amended,
     read]
      boolean SettableBaudRate;

    [DisplayName("Settable Data Bits") : amended,
    WmiDataId(20),
     Description("The SettableDataBits property determines whether the number of data bits can be set on the Win32 serial port") : amended,
     read]
      boolean SettableDataBits;

    [DisplayName("Settable Flow Control") : amended,
    WmiDataId(21),
     Description("The SettableFlowControl property determines whether the flow control can be set on the serial port") : amended,
     read]
      boolean SettableFlowControl;

    [DisplayName("Settable Parity") : amended,
    WmiDataId(22),
     Description("The SettableParity property determines whether the parity can be set on the serial port") : amended,
     read]
      boolean SettableParity;

    [DisplayName("Settable Parity Check") : amended,
    WmiDataId(23),
     Description("The SettableParityCheck property determines whether parity checking can be set on the serial port") : amended,
     read]
      boolean SettableParityCheck;

    [DisplayName("Settable Stop Bits") : amended,
    WmiDataId(24),
     Description("The SettableStopBits property determines whether the number of stop bits can be set on the serial port") : amended,
     read]
      boolean SettableStopBits;

    [DisplayName("Is Busy") : amended,
    WmiDataId(25),
     Description("The IsBusy property determines whether the serial port is busy") : amended,
     read]
      boolean IsBusy;
};

[WMI, Dynamic, Provider ("WMIProv"),
 guid("{270B9B86-B16D-11D1-BD98-00A0C906BE2D}"),
 GuidName1("SERIAL_PORT_WMI_HW_GUID"),
 HeaderName("SERIAL_WMI_HW_DATA"),
 Description("Hardware configuration for serial port") : amended,
 DisplayName("Serial Hardware Configuration") : amended
]
class MSSerial_HardwareConfiguration : MSSerial
{
    boolean Active;
    [key]
      string InstanceName;

    [DisplayName("Irq Number") : amended,
    WmiDataId(1),
     Description("The IRQNumber property indicates the number of the IRQ resource") : amended,
     read]
      uint32 IrqNumber;

    [DisplayName("Irq Vector") : amended,
    WmiDataId(2),
     Description("The Vector property indicates the vector of the IRQ resource") : amended,
     read]
      uint32 IrqVector;

    [DisplayName("Irq Level") : amended,
    WmiDataId(3),
     Description("The IRQLevel property indicates the level of the IRQ resource") : amended,
     read]
      uint32 IrqLevel;

    [DisplayName("Irq Affinity Mask") : amended,
    WmiDataId(4),
     Description("The AffinityMask property indicates the affinity mask of the IRQ resource") : amended,
     read]
      uint64 IrqAffinityMask;

    [DisplayName("Interrupt Type") : amended,
    WmiDataId(5),
     Description("The InterruptType property indicates the interrupt type of the IRQ resource") : amended,
     Values{"Latched",
             "Level"} : amended,
     ValueMap{"0",
             "1"},
     DefineValues{"SERIAL_WMI_INTTYPE_LATCHED",
                  "SERIAL_WMI_INTTYPE_LEVEL"},
     read]
      uint32 InterruptType;

    [DisplayName("Base IO Address") : amended,
    WmiDataId(6),
     Description("The BaseIOAddress is the base IO address for the serial port") : amended,
     read]
      uint64 BaseIOAddress;
};

[WMI, Dynamic, Provider ("WMIProv"),
 guid("{56415ACC-B16D-11D1-BD98-00A0C906BE2D}"),
 GuidName1("SERIAL_PORT_WMI_PERF_GUID"),
 HeaderName("SERIAL_WMI_PERF_DATA"),
 Description("Performance information for serial port") : amended,
 DisplayName("Serial Performance Data") : amended
]
class MSSerial_PerformanceInformation : MSSerial
{
    boolean Active;
    [key]
      string InstanceName;

    [DisplayName("Received Count") : amended,
    WmiDataId(1),
     Description("The ReceivedCount property indicates the number of bytes received in the current session") : amended,
     read]
      uint32 ReceivedCount;
      
    [DisplayName("Transmitted Count") : amended,
    WmiDataId(2),
     Description("The TransmittedCount property indicates the number of bytes transmitted in the current session") : amended,
     read]
      uint32 TransmittedCount;
      
    [DisplayName("Frame Error Count") : amended,
    WmiDataId(3),
     Description("The FrameErrorCount property indicates the number of framing errors that occurred in the current session") : amended,
     read]
      uint32 FrameErrorCount;
      
    [DisplayName("Serial Overrun Error Count") : amended,
    WmiDataId(4),
     Description("The SerialOverrunCount property indicates the number of serial overrun errors that occurred in the current session") : amended,
     read]
      uint32 SerialOverrunErrorCount;
      
    [DisplayName("Buffer Overrun Error Count") : amended,
    WmiDataId(5),
     Description("The BufferOverrunCount property indicates the number of buffer overrun errors that occurred in the current session") : amended,
     read]
      uint32 BufferOverrunErrorCount;
      
    [DisplayName("Parity Error Count") : amended,
    WmiDataId(6),
     Description("The ParityErrorCount property indicates the number of parity errors that occurred in the current session") : amended,
     read]
      uint32 ParityErrorCount;
};

[WMI, Dynamic, Provider ("WMIProv"),
 guid("{8209EC2A-2D6B-11d2-BA49-00A0C9062910}"),
 GuidName1("SERIAL_PORT_WMI_PROPERTIES_GUID"),
 HeaderName("SERIAL_WMI_COMMPROP"),
 Description("Communication properties for serial port") : amended
]
class MSSerial_CommProperties : MSSerial
{
    boolean Active;
    [key]
      string InstanceName;

    [
     read, WmiDataId(1),
     Description("Specifies the size, in bytes, of the entire data packet, regardless of the amount of data requested") : amended]
    uint16  wPacketLength;       // packet size, in bytes 

    [
     read, WmiDataId(2),
     Description("Specifies the version of the structure") : amended]
    uint16  wPacketVersion;      // packet version 

    [read, WmiDataId(3),
     BitValues{"SP_SERIALCOMM"} : amended,
     BitMap{"0"},
     Description("Specifies a bitmask indicating which services are implemented by this provider. The SP_SERIALCOMM value is always specified for communications providers, including modem providers.") : amended]
    uint32 dwServiceMask;       // services implemented 

    [read, WmiDataId(4),
     Description("Reserved; do not use.") : amended]
    uint32 dwReserved1;         // reserved 

    [read, WmiDataId(5),
     Description("Specifies the maximum size, in bytes, of the driver's internal output buffer. A value of zero indicates that no maximum value is imposed by the serial provider") : amended]
    uint32 dwMaxTxQueue;        // max Tx bufsize, in bytes 

    [read, WmiDataId(6),
     Description("Specifies the maximum size, in bytes, of the driver's internal input buffer. A value of zero indicates that no maximum value is imposed by the serial provider") : amended]
    uint32 dwMaxRxQueue;        // max Rx bufsize, in bytes 

    [read, WmiDataId(7),
     BitValues{"BAUD_075", "BAUD_110", "BAUD_134_5", "BAUD_150", "BAUD_300", 
            "BAUD_600", "BAUD_1200", "BAUD_1800", "BAUD_2400", "BAUD_4800", 
            "BAUD_7200", "BAUD_9600", "BAUD_14400", "BAUD_19200", "BAUD_38400",
            "BAUD_56K", "BAUD_128K", "BAUD_115200", "BAUD_57600", "BAUD_USER"} : amended,

     BitMap{"0", "1", "2", "3", "4", 
               "5", "6", "7", "8", "9", 
               "10", "11", "12", "13", "14", 
               "15", "16", "17", "18", "28" },
     Description("Specifies the maximum allowable baud rate, in bits per second (bps). This member can be one of the following values: Value Meaning") : amended]
    uint32 dwMaxBaud;           // max baud rate, in bps 

    [read, WmiDataId(8),
     ValueMap{"0x00000000", "0x00000001", "0x00000002", 
              "0x00000003", "0x00000004", "0x00000005", "0x00000006", 
              "0x00000021", "0x00000022", "0x00000100", 
              "0x00000101", "0x00000102", "0x00000103"},

     Values{ "Unspecified", "RS-232 serial port",  "Parallel port", 
             "RS-422 port", "RS-423 port","RS-449 port", "Modem device",
             "FAX device", "Scanner device", "Unspecified network bridge",
             "LAT protocol", "TCP/IP Telnet protocol", "X.25 standards"} : amended,

     Description("Specifies the specific communications provider type") : amended]
    uint32 dwProvSubType;       // specific provider type 

    [read, WmiDataId(9),
     BitValues{ "(data-terminal-ready)/DSR (data-set-ready) supported",
             "(request-to-send)/CTS (clear-to-send) supported",
             "(receive-line-signal-detect) supported",
             "Parity checking supported",
             "XON/XOFF flow control supported",
             "Settable XON/XOFF supported",
             "Total (elapsed) time-outs supported",
             "Interval time-outs supported",
             "Special character support provided",
             "Special 16-bit mode supported"} : amended,
     BitMap{"0", "1", "2", "3", "4", 
               "5", "6", "7", "8", "9"},
     Description("Specifies a bitmask indicating the capabilities offered by the provider. This member can be one of the following values") : amended]
    uint32 dwProvCapabilities;  // capabilities supported 

    [read, WmiDataId(10),
     BitValues{"Parity checking",
            "Baud rate",
            "Data bits",
            "Stop bits",
            "Handshaking (flow control)",
            "Parity checking",
            "(receive-line-signal-detect)"} : amended,
     BitMap{"0", "1", "2", "3", "4", 
               "5", "6"},
     Description("Specifies a bitmask indicating the communications parameter that can be changed") : amended]
    uint32 dwSettableParams;    // changable parameters 

    [read, WmiDataId(11),
     BitValues{"BAUD_075", "BAUD_110", "BAUD_134_5", "BAUD_150", "BAUD_300", 
            "BAUD_600", "BAUD_1200", "BAUD_1800", "BAUD_2400", "BAUD_4800", 
            "BAUD_7200", "BAUD_9600", "BAUD_14400", "BAUD_19200", "BAUD_38400",
            "BAUD_56K", "BAUD_128K", "BAUD_115200", "BAUD_57600", "BAUD_USER"} : amended,

     BitMap{"0", "1", "2", "3", "4", 
               "5", "6", "7", "8", "9", 
               "10", "11", "12", "13", "14", 
               "15", "16", "17", "18", "28" },
     Description("Specifies a bitmask indicating the baud rates that can be used") : amended]
    uint32 dwSettableBaud;      // allowable baud rates 

    [read, WmiDataId(12),
     BitValues{"5 data bits",
            "6 data bits",
            "7 data bits",
            "8 data bits",
            "16 data bits",
            "Special wide path through serial hardware lines"} : amended,

     BitMap{"0", "1", "2", "3", "4", "5"},
     Description("Specifies a bitmask indicating the number of data bits that can be set") : amended]
    uint16  wSettableData;       // allowable byte sizes 

    [read, WmiDataId(13),
     BitValues{"1 stop bit",
            "1.5 stop bits",
            "2 stop bits",
            "No parity",
            "Odd parity",
            "Even parity",
            "Mark parity",
            "Space parity"} : amended,

     BitMap{"0", "1", "2", "8", "9", "10", "11", "12"},
     Description("Specifies a bitmask indicating the stop bit and parity settings that can be selected.") : amended]
    uint16  wSettableStopParity; // stop bits/parity allowed 

    [read, WmiDataId(14),
     Description("Specifies the size, in bytes, of the driver's internal output buffer. A value of zero indicates that the value is unavailable.") : amended]
    uint32 dwCurrentTxQueue;    // Tx buffer size, in bytes 

    [read, WmiDataId(15),
     Description("Specifies the size, in bytes, of the driver's internal input buffer. A value of zero indicates that the value is unavailable.") : amended]
    uint32 dwCurrentRxQueue;    // Rx buffer size, in bytes 

    [read, WmiDataId(16),
     Description("Specifies provider-specific data.") : amended]
     uint32 dwProvSpec1;         // provider-specific data 

    [read, WmiDataId(17),
     Description("Specifies provider-specific data.") : amended]
    uint32 dwProvSpec2;         // provider-specific data 

    [
    read, WmiDataId(18),
     Description("Number of bytes of provider specific data") : amended]
    uint32 dwProvCharSize;

    [
    read, WmiDataId(19),
     WmiSizeIs("dwProvCharSize"),
     Description("Specifies provider-specific data. Applications should ignore this member unless they have detailed information about the format of the data required by the provider.") : amended]
    uint8 wcProvChar[];       // provider-specific data 


};

[abstract]
class MSParallel
{
}; 

[Dynamic, Provider("WMIProv"), WMI, 
 Description("The allocate and free counts track the port sharing of the parallel port. If the allocate count equals the free count then the port is idle. If the allocate count is greater than the free count (free count + 1) then some other driver in the system has acquired exclusive access to that port. If the allocate count stays constant at freecount+1 for an arbitrarily long period of time, then some driver may have illegally locked the port preventing other drivers from accessing the port.") : amended
,
 guid("{4BBB69EA-6853-11d2-8ECE-00C04F8EF481}"),
 HeaderName("PARPORT_WMI_ALLOC_FREE_COUNTS"),
 GuidName1("PARPORT_WMI_ALLOCATE_FREE_COUNTS_GUID"),
 DisplayName("Parallel Port Alloc Free Counts") : amended
 ]
class MSParallel_AllocFreeCounts : MSParallel
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Port Allocates") : amended,
    WmiDataId(1), 
     Description("Port allocation count") : amended,
     read] 
    uint32 PortAllocates;
    
    [DisplayName("Port Frees") : amended,
    WmiDataId(2), 
     Description("Port free count") : amended,
     read] 
    uint32 PortFrees;
    
};

[Dynamic, Provider("WMIProv"), WMI, 
 Description("Bytes transferred for each mode for the device") : amended,
 guid("{89FEF2D6-654B-11d2-9E15-00C04F8EF481}"),
 GuidName1("PARALLEL_WMI_BYTES_TRANSFERRED_GUID"),
 HeaderName("PARALLEL_WMI_LOG_INFO"),
 DisplayName("Parallel Device Bytes Transferred") : amended
 ]
class MSParallel_DeviceBytesTransferred : MSParallel
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Flags 1") : amended,
    WmiDataId(1), 
     Description("Reserved") : amended,
     read] 
    uint32 Flags1;

    [DisplayName("Flags 2") : amended,
    WmiDataId(2), 
     Description("Reserved") : amended,
     read] 
    uint32 Flags2;

    [DisplayName("spare") : amended,
    WmiDataId(3), 
     Description("Reserved") : amended,
     read] 
    uint32 spare[2];

    [DisplayName("Spp Write Count") : amended,
    WmiDataId(4), 
     Description("Bytes writtem using SPP mode") : amended,
     read] 
    sint64 SppWriteCount;

    [DisplayName("Nibble Read Count") : amended,
    WmiDataId(5), 
     Description("Bytes writtem using nibble mode") : amended,
     read] 
    sint64 NibbleReadCount;

    [DisplayName("Bounded Ecp Write Count") : amended,
    WmiDataId(6), 
     Description("Bytes writtem using bounded Ecp mode") : amended,
     read] 
    sint64 BoundedEcpWriteCount;
    [DisplayName("BoundedEcpReadCount") : amended,
    WmiDataId(7), 
     Description("Bytes read using bounded Ecp mode") : amended,
     read] 
    sint64 BoundedEcpReadCount;

    [DisplayName("Hw Ecp Write Count") : amended,
    WmiDataId(8), 
     Description("Bytes writtem using hardware Ecp mode") : amended,
     read] 
    sint64 HwEcpWriteCount;
    [DisplayName("Hw Ecp Read Count") : amended,
    WmiDataId(9), 
     Description("Bytes read using hardware Ecp mode") : amended,
     read] 
    sint64 HwEcpReadCount;

    [DisplayName("Sw Ecp Write Count") : amended,
    WmiDataId(10), 
     Description("Bytes writtem using software Ecp mode") : amended,
     read] 
    sint64 SwEcpWriteCount;
    [DisplayName("Sw Ecp Read Count") : amended,
    WmiDataId(11), 
     Description("Bytes read using software Ecp mode") : amended,
     read] 
    sint64 SwEcpReadCount;

    [DisplayName("Hw Epp Write Count") : amended,
    WmiDataId(12), 
     Description("Bytes writtem using hardware Epp mode") : amended,
     read] 
    sint64 HwEppWriteCount;
    [DisplayName("Hw Epp Read Count") : amended,
    WmiDataId(13), 
     Description("Bytes read using hardware Epp mode") : amended,
     read] 
    sint64 HwEppReadCount;

    [DisplayName("Sw Epp Write Count") : amended,
    WmiDataId(14), 
     Description("Bytes writtem using software Epp mode") : amended,
     read] 
    sint64 SwEppWriteCount;
    [DisplayName("Sw Epp Read Count") : amended,
    WmiDataId(15), 
     Description("Bytes read using software Epp mode") : amended,
     read] 
    sint64 SwEppReadCount;

    [DisplayName("Byte Read Count") : amended,
    WmiDataId(16), 
     Description("Bytes read using byte (bidirectional / PS/2) mode") : amended,
     read] 
    sint64 ByteReadCount;
    [DisplayName("Channel Nibble Read Count") : amended,
    WmiDataId(17), 
     Description("Bytes read using channelized Nibble mode (IEEE 1284.3)") : amended,
     read] 
    sint64 ChannelNibbleReadCount;
    
};


[abstract]
class MSRedbook
{
};


[Dynamic,
 Provider("WMIProv"),
 WMI,
 Description("Digital Audio Filter Driver Information (redbook)") : amended,
 GuidName1("GUID_REDBOOK_WMI_STD_DATA"),
 GuidName2("MSRedbook_DriverInformationGuid"),
 HeaderName("REDBOOK_WMI_STD_DATA"),
 guid("{b90550e7-ae0a-11d1-a571-00c04fa34730}"),
 DisplayName("Redbook Driver Information") : amended
]

class MSRedbook_DriverInformation
{
        [key, read]
        string InstanceName;

        [read]
        boolean Active;

        [WmiDataId(1),
         DefineDataId("REDBOOK_WMI_NUMBER_OF_BUFFERS"),
         read,
         write,
         Description("NumberOfBuffers*SectorsPerRead*2352 is the amount of memory used to reduce skipping." ) : amended,
         DisplayName("Number Of Buffers") : amended
        ]
        uint32 NumberOfBuffers;

        [WmiDataId(2),
         DefineDataId("REDBOOK_WMI_SECTORS_PER_READ"),
         read,
         write,
         Description("Sectors (2352 bytes each) per read.") : amended,
         DisplayName("Sectors Per Read") : amended
        ]
        uint32 SectorsPerRead;

        [WmiDataId(3),
         DefineDataId("REDBOOK_WMI_SECTORS_PER_READ_MASK"),
         read,
         write,
         Description("Bitwise mask of supported sectors per read for this drive.  The lowest bit is one sector reads.  If all bits are set, there are no restrictions.") : amended,
         DisplayName("Sectors Per Read Mask") : amended
        ]
        uint32 SectorsPerReadMask;

        [WmiDataId(4),
         DefineDataId("REDBOOK_WMI_MAX_SECTORS_PER_READ"),
         read,
         write,
         Description("Maximum sectors per read (depends on both adapter and drive).") : amended,
         DisplayName("Maximum Sectors Per Read") : amended
        ]
        uint32 MaximumSectorsPerRead;

        [WmiDataId(5),
         DefineDataId("REDBOOK_WMI_PLAY_ENABLED"),
         read,
         write,
         Description("PlayEnabled indicates the drive is currently using the RedBook filter.") : amended,
         DisplayName("Play Enabled") : amended
        ]
        boolean PlayEnabled;

        [WmiDataId(6),
         DefineDataId("REDBOOK_WMI_CDDA_SUPPORTED"),
         read,
         write,
         Description("CDDASupported indicates the drive supports digital audio for some sector sizes.") : amended,
         DisplayName("CDDA Supported") : amended
        ]
        boolean CDDASupported;

        [WmiDataId(7),
         DefineDataId("REDBOOK_WMI_CDDA_ACCURATE"),
         read,
         write,
         Description("CDDAAccurate indicates the drive acccurately reads digital audio.  This ensures the highest quality audio") : amended,
         DisplayName("CDDA Accurate") : amended
        ]
        boolean CDDAAccurate;

        [WmiDataId(8),
         read,
         Description("Reserved for future use") : amended,
         DisplayName("Reserved 1") : amended
        ]
        boolean Reserved1;

};


[Dynamic,
 Provider("WMIProv"),
 WMI,
 Description("Digital Audio Filter Driver Performance Data (redbook)") : amended,
 GuidName1("GUID_REDBOOK_WMI_PERF_DATA"),
 GuidName2("MSRedbook_PerformanceGuid"),
 HeaderName("REDBOOK_WMI_PERF_DATA"),
 guid("{b90550e8-ae0a-11d1-a571-00c04fa34730}"),
 DisplayName("Redbook Performance Information") : amended
]

class MSRedbook_Performance
{
        [key, read]
        string InstanceName;

        [read]
        boolean Active;

        [WmiDataId(1),
         DefineDataId("REDBOOK_WMI_PERF_TIME_READING_DELAY"),
         read,
         Description("Seconds spent ready to read, but unused. (*1E-7)" ) : amended,
         DisplayName("Time Read Delay") : amended
        ]
        sint64 TimeReadDelay;

        [WmiDataId(2),
         DefineDataId("REDBOOK_WMI_PERF_TIME_READING"),
         read,
         Description("Seconds spent reading data from source. (*1E-7)") : amended,
         DisplayName("Time Reading") : amended
        ]
        sint64 TimeReading;

        [WmiDataId(3),
         DefineDataId("REDBOOK_WMI_PERF_TIME_STREAMING_DELAY"),
         read,
         Description("Seconds spent ready to stream, but unused. (*1E-7)") : amended,
         DisplayName("Time Stream Delay") : amended
        ]
        sint64 TimeStreamDelay;

        [WmiDataId(4),
         DefineDataId("REDBOOK_WMI_PERF_TIME_STREAMING"),
         read,
         Description("Seconds spent streaming data. (*1E-7)") : amended,
         DisplayName("Time Streaming") : amended
        ]
        sint64 TimeStreaming;

        [WmiDataId(5),
         DefineDataId("REDBOOK_WMI_PERF_DATA_PROCESSED"),
         read,
         Description("Number of bytes of data read and streamed.") : amended,
         DisplayName("Data Processed") : amended
        ]
        sint64 DataProcessed;

        [WmiDataId(6),
         DefineDataId("REDBOOK_WMI_PERF_STREAM_PAUSED_COUNT"),
         read,
         Description("Number of times the stream has paused due to insufficient stream buffers.") : amended,
         DisplayName("Stream Paused Count") : amended
        ]
        uint32 StreamPausedCount;

};


[WMI, Dynamic, Provider("WMIProv"),
 guid("{e3dff7bd-3915-11d2-9103-00c04fb998a2}"),

 WmiExpense(1),
 Description("Enumerates Guids registered with WMI. The InstanceName is the Guid.") : amended]
class RegisteredGuids
{
    [key, read]
    string      InstanceName;

    [read]
    boolean     Active;

    [DisplayName("GuidType") : amended,
    read,
     Description("Type of guid") : amended,
     ValueMap{0, 1, 2, 3},
     Value{"Trace Control Guid", "Trace Guid", "Data Guid", "Event Guid"} : amended,
     WmiDataId(1)]    uint32     GuidType;

    [DisplayName("LoggerId") : amended,
    read,
    Description("If Trace guid and enabled, indicates the LoggerId to which this Guid is currently logging data") : amended,
     WmiDataId(2)]    uint32      LoggerId;

    [DisplayName("EnableLevel") : amended,
    read,
    Description("If trace guid and If enabled, indicates the level of logging") : amended,
     WmiDataId(3)]    uint32      EnableLevel;

    [DisplayName("EnableFlags") : amended,
    read,
    Description("If trace guid and enabled, indicates the flags currently used in logging") : amended,
     WmiDataId(4)]    uint32      EnableFlags;

    [DisplayName("IsEnabled") : amended,
    read,
    Description("Indicates whether this Guid is enabled currently. For data guids this means if collection is enabled, For event guids this means if events are enabled. For Trace control guids this means the trace logging is enabled.") : amended,
     WmiDataId(5)]    boolean     IsEnabled;

};


//*************************************************************
//***   Creates namespace for TRACE under \root\wmi
//***   EventTrace - is the root for all Trace Guids
//***   All Provider Control Guids will derive from EventTrace
//***   All Trace Data Guids will derive from their ControlGuid
//*************************************************************

[abstract]
class EventTrace
{
    [HeaderDataId(1),
     Description("Trace Event Size") : amended,
     read]
    uint16 EventSize;

    [HeaderDataId(2),
     Description("Reserved") : amended,
     read]
    uint16 ReservedHeaderField;

    [HeaderDataId(3),
     Description("Event Type") : amended,
     read]
    uint8 EventType;

    [HeaderDataId(4),
     Description("Trace Level") : amended,
     read]
    uint8 TraceLevel;

    [HeaderDataId(5),
     Description("Trace Version") : amended,
     read]
    uint16 TraceVersion;

    [HeaderDataId(6),
     Description("Thread Id") : amended,
     PointerType,
     read]
    uint64 ThreadId;

    [HeaderDataId(7),
     Description("TimeStamp") : amended,
     read]
    uint64 TimeStamp;

    [HeaderDataId(8),
     Description("Event Guid") : amended,
     read]
    uint8 EventGuid[16];

    [HeaderDataId(9),
     Description("Kernel Time") : amended,
     read]
    uint32 KernelTime;

   [HeaderDataId(10),
    Description("User Time") : amended,
    read]
   uint32 UserTime;

   [HeaderDataId(11),
    Description("Instance Id") : amended,
    read]
   uint32 InstanceId;

   [HeaderDataId(12),
    Description("Parent Guid") : amended,
    read]
    uint8 ParentGuid[16];

   [HeaderDataId(13),
    Description("Parent Instance Id") : amended,
    read]
   uint32 ParentInstanceId;

   [HeaderDataId(14),
    Description("Pointer to Mof Data") : amended,
    PointerType,
    read]
   uint32 MofData;

   [HeaderDataId(15),
    Description("Length of Mof Data") : amended,
    read]
   uint32 MofLength;
};

[Dynamic, 
 Description("Windows Kernel Trace"),
 Guid("{9e814aad-3204-11d2-9a82-006008a86939}")
]
class MSNT_SystemTrace:EventTrace
{
    [Description ("Enable Flags") : amended,
        ValueDescriptions{
            "Process creations/deletions",
            "Thread creations/deletions", 
            "image description", 
            "Disk input/output", 
            "File details", 
            "Page faults",
            "Hard page faults",
            "Network TCP/IP",
            "Registry details",
            "Debug print" } : amended,
         DefineValues{
            "EVENT_TRACE_FLAG_PROCESS",
            "EVENT_TRACE_FLAG_THREAD",
            "EVENT_TRACE_FLAG_IMAGE_LOAD",
            "EVENT_TRACE_FLAG_DISK_IO",
            "EVENT_TRACE_FLAG_DISK_FILE_IO",
            "EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS",
            "EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS",
            "EVENT_TRACE_FLAG_NETWORK_TCPIP",
            "EVENT_TRACE_FLAG_REGISTRY",
            "EVENT_TRACE_FLAG_DBGPRINT" },
        Values{ 
            "process", 
            "thread", 
            "img", 
            "disk", 
            "file",
            "pf", 
            "hf", 
            "net", 
            "registry", 
            "dbgprint" }: amended,
        ValueMap{ 
            "0x00000001",
            "0x00000002",
            "0x00000004",
            "0x00000100",
            "0x00000200",
            "0x00001000",
            "0x00002000",
            "0x00010000",
            "0x00020000",
            "0x00040000" }
    ] 
    uint32 Flags;

};

[Dynamic,
 Description("Event Trace Event") : amended,
 Guid("{68fdd900-4a3e-11d1-84f4-0000f80464e3}"),
 DisplayName("EventTrace") : amended
]
class EventTraceEvent:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Event Trace Event") : amended,
 EventType(0),
 EventTypeName("Header") :amended
]
class EventTrace_Header:EventTraceEvent
{
    [WmiDataId(1),
     Description("Buffer Size in Bytes") : amended,
     read]
     uint32  BufferSize;
    [WmiDataId(2),
     Description("Event Trace Version") : amended,
     read]
     uint32  Version;
    [WmiDataId(3),
     Description("Windows Build Number") : amended,
     read]
     uint32  ProviderVersion;
    [WmiDataId(4),
     Description("Number Of Processors") : amended,
     read]
     uint32  NumberOfProcessors;
    [WmiDataId(5),
     Description("Collection End Time") : amended,
     read]
     uint64  EndTime;
    [WmiDataId(6),
     Description("Timer Resolution") : amended,
     read]
     uint32  TimerResolution;
    [WmiDataId(7),
     Description("Maximum File Size in MBytes") : amended,
     read]
     uint32  MaxFileSize;
    [WmiDataId(8),
     Description("LogFileMode") : amended,
     format("x"),
     read]
     uint32  LogFileMode;
    [WmiDataId(9),
     Description("Number of Buffers Written") : amended,
     read]
     uint32  BuffersWritten;
    [WmiDataId(10),
     Description("Buffer Number with earliest TimeStamp for a Cicular LogFile") : amended,
     read]
     uint32  StartBuffers;
    [WmiDataId(11),
     Description("Pointer Size in Bytes") : amended,
     read]
     uint32  PointerSize;
    [WmiDataId(12),
     Description("Number of Events Lost during collection") : amended,
     read]
     uint32  EventsLost;
    [WmiDataId(13),
     Description("CPU Speed in MHz") : amended,
     read]
     uint32  CPUSpeed;
    [WmiDataId(14),
     Description("Logger Name") : amended,
     pointer,
     read]
     uint32  LoggerName;
    [WmiDataId(15),
     Description("LogFile Name") : amended,
     pointer,
     read]
     uint32  LogFileName;
    [WmiDataId(16),
     Description("TimeZoneInformation") : amended,
     extension("NoPrint"),
     read]
     uint8 TimeZoneInformation[176];
    [WmiDataId(17),
     Description("BootTime") : amended,
     read]
     uint64  BootTime;
    [WmiDataId(18),
     Description("Performance counter frequency in counts per second") : amended,
     read]
     uint64  PerfFreq;
    [WmiDataId(19),
     Description("StartTime") : amended,
     read]
     uint64  StartTime;
    [WmiDataId(20),
     Description("ReservedFlags") : amended,
     read]
     uint32  ReservedFlags;
    [WmiDataId(21),
     Description("Number of Buffers Lost during collection") : amended,
     read]
     uint32  BuffersLost;
};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 Guid("{3d6fa8d0-fe05-11d0-9dda-00c04fd7ba7c}"),
 EventVersion(0),
 DisplayName("Process") : amended
]
class Process_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Process_V0_TypeGroup1:Process_V0
{
    [WmiDataId(1),
     Description("Process ID") : amended,
     pointer,
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("Parent Process ID") : amended,
     pointer,
     read]
     uint32  ParentId;
    [WmiDataId(3),
     Description("User SID") : amended,
     extension("Sid"),
     read]
     object  UserSID;
    [WmiDataId(4),
     Description("ImageFileName") : amended,
     StringTermination("NullTerminated"),
     read]
     string  ImageFileName;
};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 Guid("{3d6fa8d0-fe05-11d0-9dda-00c04fd7ba7c}"),
 EventVersion(1),
 DisplayName("Process") : amended
]
class Process:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Process_TypeGroup1:Process
{
    [WmiDataId(1),
     Description("PageDirectoryBase") : amended,
     pointer,
     read]
     uint32  PageDirectoryBase;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(3),
     Description("ParentId") : amended,
     read]
     uint32  ParentId;
    [WmiDataId(4),
     Description("SessionId") : amended,
     read]
     uint32  SessionId;
    [WmiDataId(5),
     Description("ExitStatus") : amended,
     read]
     sint32  ExitStatus;
    [WmiDataId(6),
     Description("UserSID") : amended,
     extension("Sid"),
     read]
     object  UserSID;
    [WmiDataId(7),
     Description("ImageFileName") : amended,
     StringTermination("NullTerminated"),
     read]
     string  ImageFileName;
};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 Guid("{3d6fa8d1-fe05-11d0-9dda-00c04fd7ba7c}"),
 EventVersion(0),
 DisplayName("Thread") : amended
]
class Thread_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Thread_V0_TypeGroup1:Thread_V0
{
    [WmiDataId(1),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  TThreadId;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 Guid("{3d6fa8d1-fe05-11d0-9dda-00c04fd7ba7c}"),
 EventVersion(1),
 DisplayName("Thread") : amended
]
class Thread:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{1, 3},
 EventTypeName{"Start", "DCStart"} : amended
]
class Thread_TypeGroup1:Thread
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     read]
     uint32  TThreadId;
    [WmiDataId(3),
     Description("StackBase") : amended,
     pointer,
     read]
     uint32  StackBase;
    [WmiDataId(4),
     Description("StackLimit") : amended,
     pointer,
     read]
     uint32  StackLimit;
    [WmiDataId(5),
     Description("UserStackBase") : amended,
     pointer,
     read]
     uint32  UserStackBase;
    [WmiDataId(6),
     Description("UserStackLimit") : amended,
     pointer,
     read]
     uint32  UserStackLimit;
    [WmiDataId(7),
     Description("StartAddr") : amended,
     pointer,
     read]
     uint32  StartAddr;
    [WmiDataId(8),
     Description("Win32StartAddr") : amended,
     pointer,
     read]
     uint32  Win32StartAddr;
    [WmiDataId(9),
     Description("WaitMode") : amended,
     format("c"),
     read]
     sint8  WaitMode;
};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{2, 4},
 EventTypeName{"End", "DCEnd"} : amended
]
class Thread_TypeGroup2:Thread
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     read]
     uint32  TThreadId;
};

[Dynamic,
 Description("I/O Read/Write Event") : amended,
 Guid("{3d6fa8d4-fe05-11d0-9dda-00c04fd7ba7c}"),
 DisplayName("DiskIo") : amended
]
class DiskIo:MSNT_SystemTrace
{

};

[Dynamic,
 Description("I/O Read/Write Event") : amended,
 EventType{10, 11},
 EventTypeName{"Read", "Write"} : amended
]
class DiskIo_TypeGroup1:DiskIo
{
    [WmiDataId(1),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(2),
     Description("IrpFlags") : amended,
     format("x"),
     read]
     uint32  IrpFlags;
    [WmiDataId(3),
     Description("TransferSize") : amended,
     read]
     uint32  TransferSize;
    [WmiDataId(4),
     Description("QueueDepth") : amended,
     read]
     uint32  QueueDepth;
    [WmiDataId(5),
     Description("ByteOffset") : amended,
     read]
     sint64  ByteOffset;
    [WmiDataId(6),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
};

[Dynamic,
 Description("Registry") : amended,
 Guid("{ae53722e-c863-11d2-8659-00c04fa321a1}"),
 EventVersion(0),
 DisplayName("Registry") : amended
]
class Registry_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Registry") : amended,
 EventType{10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21},
 EventTypeName{"Create", "Open", "Delete", "Query", "SetValue", "DeleteValue", "QueryValue", "EnumerateKey", "EnumerateValueKey", "QueryMultipleValue", "SetInformation", "Flush"} : amended
]
class Registry_V0_TypeGroup1:Registry_V0
{
    [WmiDataId(1),
     Description("Status") : amended,
     pointer,
     read]
     uint32  Status;
    [WmiDataId(2),
     Description("KeyHandle") : amended,
     pointer,
     read]
     uint32  KeyHandle;
    [WmiDataId(3),
     Description("ElapsedTime") : amended,
     read]
     sint64  ElapsedTime;
    [WmiDataId(4),
     Description("KeyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  KeyName;
};

[Dynamic,
 Description("Registry") : amended,
 Guid("{ae53722e-c863-11d2-8659-00c04fa321a1}"),
 EventVersion(1),
 DisplayName("Registry") : amended
]
class Registry:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Registry") : amended,
 EventType{10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22},
 EventTypeName{"Create", "Open", "Delete", "Query", "SetValue", "DeleteValue", "QueryValue", "EnumerateKey", "EnumerateValueKey", "QueryMultipleValue", "SetInformation", "Flush", "RunDown"} : amended
]
class Registry_TypeGroup1:Registry
{
    [WmiDataId(1),
     Description("Status") : amended,
     pointer,
     read]
     uint32  Status;
    [WmiDataId(2),
     Description("KeyHandle") : amended,
     pointer,
     read]
     uint32  KeyHandle;
    [WmiDataId(3),
     Description("ElapsedTime") : amended,
     read]
     sint64  ElapsedTime;
    [WmiDataId(4),
     Description("Index") : amended,
     read]
     uint32  Index;
    [WmiDataId(5),
     Description("KeyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  KeyName;
};


[Dynamic,
 Description("File Name") : amended,
 Guid("{90cbdc39-4a3e-11d1-84f4-0000f80464e3}"),
 EventVersion(0),
 DisplayName("FileIo") : amended
]
class FileIo_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("File Name") : amended,
 EventType(0),
 EventTypeName("Name") : amended
]
class FileIo_V0_Name:FileIo_V0
{
    [WmiDataId(1),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(2),
     Description("FileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  FileName;
};

[Dynamic,
 Description("File Name") : amended,
 Guid("{90cbdc39-4a3e-11d1-84f4-0000f80464e3}"),
 EventVersion(1),
 DisplayName("FileIo") : amended
]
class FileIo:MSNT_SystemTrace
{

};

[Dynamic,
 Description("File Name") : amended,
 EventType{0, 32},
 EventTypeName{"Name", "FileCreate"} : amended
]
class FileIo_Name:FileIo
{
    [WmiDataId(1),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(2),
     Description("FileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  FileName;
};

[Dynamic,
 Description("TcpIp Send/Receive") : amended,
 Guid("{9a280ac0-c8e0-11d1-84e2-00c04fb998a2}"),
 EventVersion(0),
 DisplayName("TcpIp") : amended
]
class TcpIp_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("TcpIp Send/Receive") : amended,
 EventType{10, 11, 12, 13, 14, 15},
 EventTypeName{"Send", "Recv", "Connect", "Disconnect", "Retransmit", "Accept"} : amended
]
class TcpIp_V0_TypeGroup1:TcpIp_V0
{
    [WmiDataId(1),
     Description("Remote IP Address") : amended,
     extension("IPAddr"),
     read]
     object  daddr;
    [WmiDataId(2),
     Description("Local IP Address") : amended,
     extension("IPAddr"),
     read]
     object  saddr;
    [WmiDataId(3),
     Description("Remote Port") : amended,
     extension("Port"),
     read]
     object  dport;
    [WmiDataId(4),
     Description("Local Port") : amended,
     extension("Port"),
     read]
     object  sport;
    [WmiDataId(5),
     Description("Transfer Size in Bytes") : amended,
     read]
     uint32  size;
    [WmiDataId(6),
     Description("Process ID") : amended,
     read]
     uint32  PID;
};

[Dynamic,
 Description("TcpIp Send/Receive") : amended,
 Guid("{9a280ac0-c8e0-11d1-84e2-00c04fb998a2}"),
 DisplayName("TcpIp") : amended
]
class TcpIp:MSNT_SystemTrace
{

};

[Dynamic,
 Description("TcpIp Send/Receive") : amended,
 EventType{10, 11, 12, 13, 14, 15, 16},
 EventTypeName{"Send", "Recv", "Connect", "Disconnect", "Retransmit", "Accept", "Reconnect"} : amended
]
class TcpIp_TypeGroup1:TcpIp
{
    [WmiDataId(1),
     Description("Process ID") : amended,
     read]
     uint32  PID;
    [WmiDataId(2),
     Description("Transfer Size in Bytes") : amended,
     read]
     uint32  size;
    [WmiDataId(3),
     Description("Remote IP Address") : amended,
     extension("IPAddr"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddr"),
     read]
     object  saddr;
    [WmiDataId(5),
     Description("Remote Port") : amended,
     extension("Port"),
     read]
     object  dport;
    [WmiDataId(6),
     Description("Local Port") : amended,
     extension("Port"),
     read]
     object  sport;
};

[Dynamic,
 Description("UcpIp Send/Receive") : amended,
 Guid("{bf3a50c5-a9c9-4988-a005-2df0b7c80f80}"),
 EventVersion(0),
 DisplayName("UdpIp") : amended
]
class UdpIp_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("UcpIp Send/Receive") : amended,
 EventType{10, 11},
 EventTypeName{"Send", "Recv"} : amended
]
class UdpIp_V0_TypeGroup1:UdpIp_V0
{
    [WmiDataId(1),
     Description("Process ID") : amended,
     pointer,
     read]
     uint32  context;
    [WmiDataId(2),
     Description("Local IP Address") : amended,
     extension("IPAddr"),
     read]
     object  saddr;
    [WmiDataId(3),
     Description("Local Port") : amended,
     extension("Port"),
     read]
     object  sport;
    [WmiDataId(4),
     Description("Transfer Size in Bytes") : amended,
     read]
     uint16  size;
    [WmiDataId(5),
     Description("Remote IP Address") : amended,
     extension("IPAddr"),
     read]
     object  daddr;
    [WmiDataId(6),
     Description("Remote Port") : amended,
     extension("Port"),
     read]
     object  dport;
    [WmiDataId(7),
     Description("Number of Bytes successfully sent") : amended,
     read]
     uint16  dsize;
};


[Dynamic,
 Description("UdpIp Send/Receive") : amended,
 Guid("{bf3a50c5-a9c9-4988-a005-2df0b7c80f80}"),
 DisplayName("UdpIp") : amended
]
class UdpIp:MSNT_SystemTrace
{

};

[Dynamic,
 Description("UdpIp Send/Receive") : amended,
 EventType{10, 11},
 EventTypeName{"Send", "Recv"} : amended
]
class UdpIp_TypeGroup1:UdpIp
{
    [WmiDataId(1),
     Description("Process ID") : amended,
     read]
     uint32  PID;
    [WmiDataId(2),
     Description("Transfer Size in Bytes") : amended,
     read]
     uint32  size;
    [WmiDataId(3),
     Description("Remote IP Address") : amended,
     extension("IPAddr"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddr"),
     read]
     object  saddr;
    [WmiDataId(5),
     Description("Remote Port") : amended,
     extension("Port"),
     read]
     object  dport;
    [WmiDataId(6),
     Description("Local Port") : amended,
     extension("Port"),
     read]
     object  sport;
};

[Dynamic,
 Description("Image Load") : amended,
 Guid("{2cb15d1d-5fc1-11d2-abe1-00a0c911f518}"),
 EventVersion(0),
 DisplayName("Image") : amended
]
class Image_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Image Load") : amended,
 EventType(10),
 EventTypeName("Load") : amended
]
class Image_V0_Load:Image_V0
{
    [WmiDataId(1),
     Description("BaseAddress") : amended,
     pointer,
     read]
     uint32  BaseAddress;
    [WmiDataId(2),
     Description("ModuleSize") : amended,
     read]
     uint32  ModuleSize;
    [WmiDataId(3),
     Description("ImageFileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  ImageFileName;
};

[Dynamic,
 Description("Image Load") : amended,
 Guid("{2cb15d1d-5fc1-11d2-abe1-00a0c911f518}"),
 EventVersion(1),
 DisplayName("Image") : amended
]
class Image:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Image Load") : amended,
 EventType(10),
 EventTypeName("Load") : amended
]
class Image_Load:Image
{
    [WmiDataId(1),
     Description("ImageBase") : amended,
     pointer,
     read]
     uint32  ImageBase;
    [WmiDataId(2),
     Description("ImageSize") : amended,
     pointer,
     read]
     uint32  ImageSize;
    [WmiDataId(3),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(4),
     Description("FileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  FileName;
};

[Dynamic,
 Description("Page Fault Event") : amended,
 Guid("{3d6fa8d3-fe05-11d0-9dda-00c04fd7ba7c}"),
 DisplayName("PageFault") : amended
]
class PageFault:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Page Fault Event") : amended,
 EventType{10, 11, 12, 13, 14},
 EventTypeName{"TransitionFault", "DemandZeroFault", "CopyOnWrite", "GuardPageFault", "HardPageFault"} : amended
]
class PageFault_TransitionFault:PageFault
{
    [WmiDataId(1),
     Description("VirtualAddress") : amended,
     pointer,
     read]
     uint32  VirtualAddress;
    [WmiDataId(2),
     Description("ProgramCounter") : amended,
     pointer,
     read]
     uint32  ProgramCounter;
};

[Dynamic,
 Description("Hardware Configuration") : amended,
 Guid("{01853a65-418f-4f36-aefc-dc0f1d2fd235}"),
 DisplayName("HWConfig") : amended
]
class HWConfig:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Hardware Configuration") : amended,
 EventType(10),
 EventTypeName("CPU") : amended
]
class HWConfig_CPU:HWConfig
{
    [WmiDataId(1),
     Description("MHz") : amended,
     read]
     uint32  MHz;
    [WmiDataId(2),
     Description("NumberOfProcessors") : amended,
     read]
     uint32  NumberOfProcessors;
    [WmiDataId(3),
     Description("MemSize") : amended,
     read]
     uint32  MemSize;
    [WmiDataId(4),
     Description("PageSize") : amended,
     read]
     uint32  PageSize;
    [WmiDataId(5),
     Description("AllocationGranularity") : amended,
     read]
     uint32  AllocationGranularity;
    [WmiDataId(6),
     Description("ComputerName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  ComputerName;
};

[Dynamic,
 Description("Hardware Configuration") : amended,
 EventType(11),
 EventTypeName("PhyDisk") : amended
]
class HWConfig_PhyDisk:HWConfig
{
    [WmiDataId(1),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(2),
     Description("BytesPerSector") : amended,
     read]
     uint32  BytesPerSector;
    [WmiDataId(3),
     Description("SectorsPerTrack") : amended,
     read]
     uint32  SectorsPerTrack;
    [WmiDataId(4),
     Description("TracksPerCylinder") : amended,
     read]
     uint32  TracksPerCylinder;
    [WmiDataId(5),
     Description("Cylinders") : amended,
     read]
     uint64  Cylinders;
    [WmiDataId(6),
     Description("SCSIPort") : amended,
     read]
     uint32  SCSIPort;
    [WmiDataId(7),
     Description("SCSIPath") : amended,
     read]
     uint32  SCSIPath;
    [WmiDataId(8),
     Description("SCSITarget") : amended,
     read]
     uint32  SCSITarget;
    [WmiDataId(9),
     Description("SCSILun") : amended,
     read]
     uint32  SCSILun;
    [WmiDataId(10),
     Description("Manufacturer") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  Manufacturer;
};

[Dynamic,
 Description("Hardware Configuration") : amended,
 EventType(12),
 EventTypeName("LogDisk") : amended
]
class HWConfig_LogDisk:HWConfig
{
    [WmiDataId(1),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(2),
     Description("Pad") : amended,
     read]
     uint32  Pad;
    [WmiDataId(3),
     Description("StartOffset") : amended,
     read]
     uint64  StartOffset;
    [WmiDataId(4),
     Description("PartitionSize") : amended,
     read]
     uint64  PartitionSize;
};

[Dynamic,
 Description("Hardware Configuration") : amended,
 EventType(13),
 EventTypeName("NIC") : amended
]
class HWConfig_NIC:HWConfig
{
    [WmiDataId(1),
     Description("NICName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  NICName;
};

//
// Tape
[abstract]
class MSTapeDriver
{
}; 

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Tape Drive Parameters") : amended,
 guid("{B9A8CFD5-8D72-47a4-AC0E-284A3200F4FB}"),
 HeaderName("WMI_TAPE_DRIVE_PARAMETERS"),
 GuidName1("WMI_TAPE_DRIVE_PARAMETERS_GUID"),
 DisplayName("Tape Drive Parameters") : amended
 ]
class MSTapeDriveParam : MSTapeDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Maximum Block Size") : amended,
    WmiDataId(1),
     Description("Maximum block size supported") : amended,
     read]
    uint32 MaximumBlockSize;
    
    [DisplayName("Minimum Block Size") : amended,
    WmiDataId(2),
     Description("Minimum block size supported") : amended,
     read]
    uint32 MinimumBlockSize;
    
    [DisplayName("Default Block Size") : amended,
    WmiDataId(3),
     Description("Default block size supported") : amended,
     read]
    uint32 DefaultBlockSize;
    
    [DisplayName("Maximum Partition Count") : amended,
    WmiDataId(4),
     Description("Maximum number of partitions allowed.") : amended,
     read]
    uint32 MaximumPartitionCount;
    
    [DisplayName("Compression Capable") : amended,
     WmiDataId(5),
     Description("TRUE if drive supports compression.") : amended,
     read]
    boolean CompressionCapable; 
    
    [WmiDataId(6),
     DisplayName("Compression Enabled") : amended,
     Description("TRUE if compression is enabled.") : amended,
     read]
    boolean CompressionEnabled; 
    
    [WmiDataId(7),
     DisplayName("Report Setmarks") : amended,
     Description("TRUE if drive reports setmarks") : amended,
     read]
    boolean ReportSetmarks; 
    
    [WmiDataId(8),
     DisplayName("Hardware Error Correction") : amended,
     Description("TRUE if drive supports hardware error correction") : amended,
     read]
    boolean HardwareErrorCorrection; 
};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Tape Media Capacity") : amended,
 guid("{8C2147A4-FF29-4336-B8A4-227B54CC0966}"),
 HeaderName("WMI_TAPE_MEDIA_PARAMETERS"),
 GuidName1("WMI_TAPE_MEDIA_PARAMETERS_GUID"),
 DisplayName("Tape Media Capacity") : amended
 ]
class MSTapeMediaCapacity : MSTapeDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Maximum Capacity") : amended,
     WmiDataId(1),
     Description("Maximum capacity of the media") : amended,
     read]
    uint64 MaximumCapacity; 
    
    [DisplayName("Available Capacity") : amended,
     WmiDataId(2),
     Description("Available capacity of the media") : amended,
     read]
    uint64 AvailableCapacity;
     
    [DisplayName("Block Size") : amended,
     WmiDataId(3),
     Description("Current blocksize") : amended,
     read]
    uint32 BlockSize;
    
    [DisplayName("Partition Count") : amended,
     WmiDataId(4),
     Description("Current number of partitions") : amended,
     read]
    uint32 PartitionCount;
    
    [DisplayName("Media Write Protected") : amended,
     WmiDataId(5),
     Description("TRUE if media is write protected") : amended,
     read]
    boolean MediaWriteProtected;
};


[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Tape Symbolic Name") : amended,
 guid("{3FB828F7-F119-4066-B1E6-DB407CE9DE91}"),
 HeaderName("WMI_TAPE_SYMBOLIC_NAME"),
 GuidName1("WMI_TAPE_SYMBOLIC_NAME_GUID"),
 DisplayName("Tape Symbolic Name") : amended
 ]
class MSTapeSymbolicName : MSTapeDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;
    

    [DisplayName("Tape symbolic name") : amended,
     WmiDataId(1),
     Description("Symbolic name such as Tape0") : amended,
     read]
    string TapeSymbolicName;
};
    
[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Tape Drive Problem Warning") : amended,
 guid("{BC4DD36C-FA66-4080-87A0-0C5922EB7887}"),
 HeaderName("WMI_TAPE_PROBLEM_WARNING"),
 GuidName1("WMI_TAPE_PROBLEM_WARNING_GUID"),
 DisplayName("Tape Problem Event") : amended
 ]
class MSTapeDriveProblemEvent : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Drive Problem Type") : amended,
     WmiDataId(1),
     Description("Tape drive problem warning event") : amended,
     read]
    uint32 DriveProblemType;
    
    [WmiDataId(2),
     DisplayName("Tape Data") : amended,
     Description("Tape drive problem data") : amended,
     read]
    uint8 TapeData[512];
};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("IO Read Write Errors") : amended,
 guid("{58FD29F9-B516-40fd-871A-7EE76D5BB53E}"),
 HeaderName("WMI_TAPE_PROBLEM_IO_ERROR"),
 GuidName1("WMI_TAPE_PROBLEM_IO_ERROR_GUID"),
 DisplayName("Tape Io Error") : amended
 ]
class MSTapeProblemIoError : MSTapeDriver
{

    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Read Corrected Without Delay") : amended,
     WmiDataId(1),
     Description("Read errors corrected without much delay") : amended,
     read]
    uint32 ReadCorrectedWithoutDelay;

    [DisplayName("Read Corrected With Delay") : amended,
     WmiDataId(2),
     Description("Read errors corrected with substantial delay") : amended,
     read]
    uint32 ReadCorrectedWithDelay;
    
    [DisplayName("Read Total Errors") : amended,
     WmiDataId(3),
     Description("Total number of Read errors") : amended,
     read]
    uint32 ReadTotalErrors;
    
    [DisplayName("Read Total Corrected Errors") : amended,
     WmiDataId(4),
     Description("Total number of read errors that were corrected") : amended,
     read]
    uint32 ReadTotalCorrectedErrors;
    
    [DisplayName("Read Total Uncorrected Errors") : amended,
     WmiDataId(5),
     Description("Total number of uncorrected read errors") : amended,
     read]
    uint32 ReadTotalUncorrectedErrors;
    
    [DisplayName("Read Correction Algorithm Processed") : amended,
     WmiDataId(6),
     Description("Number of times correction algorithm was processed for read") : amended,
     read]
    uint32 ReadCorrectionAlgorithmProcessed;
    
    [DisplayName("Write Corrected Without Delay") : amended,
     WmiDataId(7),
     Description("Write errors corrected without much delay") : amended,
     read]
    uint32 WriteCorrectedWithoutDelay;

    [DisplayName("Write Corrected With Delay") : amended,
     WmiDataId(8),
     Description("Write errors corrected with substantial delay") : amended,
     read]
    uint32 WriteCorrectedWithDelay;
    
    [DisplayName("Write Total Errors") : amended,
     WmiDataId(9),
     Description("Total number of Read errors") : amended,
     read]
    uint32 WriteTotalErrors;
    
    [DisplayName("Write Total Corrected Errors") : amended,
     WmiDataId(10),
     Description("Total number of write errors that were corrected") : amended,
     read]
    uint32 WriteTotalCorrectedErrors;
    
    [DisplayName("Write Total Uncorrected Errors") : amended,
     WmiDataId(11),
     Description("Total number of uncorrected write errors") : amended,
     read]
    uint32 WriteTotalUncorrectedErrors;
    
    [DisplayName("Write Correction Algorithm Processed") : amended,
     WmiDataId(12),
     Description("Number of times correction algorithm was processed for write") : amended,
     read]
    uint32 WriteCorrectionAlgorithmProcessed;
    
    [DisplayName("Non Medium Errors") : amended,
     WmiDataId(13),
     Description("Errors not related to medium") : amended,
     read]
    uint32 NonMediumErrors;

};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Device Errors") : amended,
 guid("{43EC6B13-10BB-4bf6-B716-1C1E2F10BB5F}"),
 HeaderName("WMI_TAPE_PROBLEM_DEVICE_ERROR"),
 GuidName1("WMI_TAPE_PROBLEM_DEVICE_ERROR_GUID"),
 DisplayName("Tape Device Error") : amended
 ]
class MSTapeProblemDeviceError : MSTapeDriver
{

    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Read Warning") : amended,
     WmiDataId(1),
     Description("WARNING : Drive is experiencing read problem.") : amended,
     read]
    boolean ReadWarning;
    
    [DisplayName("Write Warning") : amended,
     WmiDataId(2),
     Description("WARNING : Drive is experiencing write problem.") : amended,
     read]
    boolean WriteWarning;
    
    [DisplayName("Hard Error") : amended,
     WmiDataId(3),
     Description("Drive hardware problem") : amended,
     read]
    boolean HardError;  
    
    [DisplayName("Read Failure") : amended,
     WmiDataId(4),
     Description("Critical Error : Too many read errors.") : amended,
     read]
    boolean ReadFailure; 
    
    [DisplayName("Write Failure") : amended,
     WmiDataId(5),
     Description("Critical Error : Too many write errors.") : amended,
     read]
    boolean WriteFailure; 
    
    [DisplayName("Unsupported Format") : amended,
     WmiDataId(6),
     Description("Tape format not supported") : amended,
     read]
    boolean UnsupportedFormat; 
      
    [DisplayName("Tape Snapped") : amended,
     WmiDataId(7),
     Description("Tape is snapped. Replace media") : amended,
     read]
     boolean TapeSnapped;
     
    [DisplayName("Drive Requires Cleaning") : amended,
     WmiDataId(8),
     Description("Drive Requires Cleaning") : amended,
     read]
    boolean DriveRequiresCleaning; 
      
    [DisplayName("Time To Clean Drive") : amended,
     WmiDataId(9),
     Description("It's time to clean the drive") : amended,
     read]
    boolean TimetoCleanDrive; 
      
    [DisplayName("Drive Hardware Error") : amended,
     WmiDataId(10),
     Description("Hardware error. Check drive") : amended,
     read]
    boolean DriveHardwareError; 
      
    [DisplayName("Scsi Interface Error") : amended,
     WmiDataId(11),
     Description("Some error in cabling, or connection.") : amended,
     read]
    boolean ScsiInterfaceError; 
    
    [DisplayName("Media Life") : amended,
     WmiDataId(12),
     Description("Critical error: Media life expired.") : amended,
     read]
    boolean MediaLife; 
};

//
// Medium Changer Libraries
[abstract]
class MSChangerDriver
{
}; 

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Changer Parameters") : amended,
 guid("{24EB52AC-7C77-438b-AB61-D024DAB0C03A}"),
 HeaderName("WMI_CHANGER_PARAMETERS"),
 GuidName1("WMI_CHANGER_PARAMETERS_GUID"),
 DisplayName("Changer Parameters") : amended
 ]
class MSChangerParameters : MSChangerDriver
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Number Of Slots") : amended,
     WmiDataId(1),
     Description("Number of slots in the changer") : amended,
     read]
    uint32 NumberOfSlots;
    
    [DisplayName("Number Of Drives") : amended,
     WmiDataId(2),
     Description("Number of drives in the changer") : amended,
     read]
    uint32 NumberOfDrives;

    [DisplayName("Number Of IE Ports") : amended,
     WmiDataId(3),
     Description("Number of IEPorts in the changer") : amended,
     read]
    uint32 NumberOfIEPorts;

    [DisplayName("Number Of Transports") : amended,
     WmiDataId(4),
     Description("Number of transport in the changer") : amended,
     read]
    uint32 NumberOfTransports;
  
    [DisplayName("Number Of Doors") : amended,
     WmiDataId(5),
     Description("Number of doors in the changer") : amended,
     read]
    uint32 NumberOfDoors;
    
    [DisplayName("Number Of Cleaner Slots") : amended,
     WmiDataId(6),
     Description("Number of slots for cleaner cartridge in the changer") : amended,
     read]
    uint32 NumberOfCleanerSlots;
    
    [
     DisplayName("Magazine Size") : amended,
     WmiDataId(7),
     Description("Magazine size if one exists") : amended,
     read]
    uint32 MagazineSize;
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("Changer Problem Warning") : amended,
 guid("{45DB06A5-20D5-4de3-A36C-3AB974600A4C}"),
 HeaderName("WMI_CHANGER_PROBLEM_WARNING"),
 GuidName1("WMI_CHANGER_PROBLEM_WARNING_GUID"),
 DisplayName("Changer Problem Event") : amended
 ]
class MSChangerProblemEvent : WmiEvent
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [DisplayName("Changer Problem Type") : amended,
     WmiDataId(1),
     Description("Changer library problem warning type") : amended,
     read]
    uint32 ChangerProblemType;

    [DisplayName("Changer Data") : amended,
     WmiDataId(2),
     Description("Changer problem data") : amended,
     read]
    uint8 ChangerData[512];
};

[Dynamic, Provider("WMIProv"),
 WMI, 
 Description("Changer Errors") : amended,
 guid("{56B396A8-0B95-42fe-BBCE-D36FDA904F8E}"),
 HeaderName("WMI_CHANGER_PROBLEM_DEVICE_ERROR"),
 GuidName1("WMI_CHANGER_PROBLEM_DEVICE_ERROR_GUID"),
 DisplayName("Changer Device Error") : amended
 ]
class MSChangerProblemDeviceError : MSChangerDriver
{

    [key, read] 
     string InstanceName;
    [read] boolean Active;
    
    [DisplayName("Changer Problem Type") : amended,
     WmiDataId(1),
     Description("Changer library problem warning type") : amended,
     read]
    uint32 ChangerProblemType;

};

[abstract]
class MSDeviceUI
{
};

[WMI, Dynamic, Provider ("WMIProv"),
 guid("{4504B1D4-C5EE-4df6-951F-16180E3DD815}"),
 HeaderName("DEVICE_UI_FIRMWARE_REVISION"),
 GuidName1("DEVICE_UI_FIRMWARE_REVISION_GUID"),
 Description("Firmware Revision" ) : amended,
 DisplayName("Device Firmware Revision") : amended
]
class MSDeviceUI_FirmwareRevision : MSDeviceUI
{
    boolean Active;
    [key]
      string InstanceName;

    [DisplayName("Firmware Revision") : amended,
     WmiDataId(1),
     Description("Firmware Revision") : amended,
     read]
      string FirmwareRevision;
};