/*++

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
        Processor Power Management
        NDIS
        SMBIOS Data
        Keyboard
        Mouse
        Disk
        IDE
        Serial
        Temperature via ACPI
        Monitor

Revision History:

--*/

#pragma namespace("\\\\.\\root\\wmi")
#pragma classflags("forceupdate")
#pragma autorecover

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

//
// WHEA Management Interface Classes
//

[abstract]
class WHEA
{
};

[WMI,
 Dynamic, 
 Provider("WMIProv"),
 Locale("MS\\0x409"),
 Description("WHEA Error Injection Interface") : amended,
 guid("{e808ff73-2093-472a-a5cc-df24f031b035}")
]
class WHEAErrorInjectionMethods : WHEA
{
    [key, read]
     string InstanceName;

    [read] boolean Active;

    [WmiMethodId(1),
     Implemented,
     DisplayName("Get Error Injection Capabilities") : amended,
     HeaderName("GET_INJECTION_CAPABILITIES"),
     Description("Returns information describing the platform's hardware error injection capabilities") : amended
    ]
     void GetErrorInjectionCapabilitiesRtn(
         [out] uint32 Status,
         [out] uint32 Capabilities
         );

    [WmiMethodId(2),
     Implemented,
     DisplayName("Inject Hardware Error") : amended,
     HeaderName("INJECT_HARDWARE_ERROR"),
     Description("Injects hardware Error")  : amended
    ]
    void InjectErrorRtn(
        [in] uint32 ErrorType,
        [in] uint64 Parameter1,
        [in] uint64 Parameter2,
        [in] uint64 Parameter3,
        [in] uint64 Parameter4,
        [out] uint32 Status
        );
};

[WMI,
 Dynamic, 
 Provider("WMIProv"),
 Locale("MS\\0x409"),
 Description("WHEA Error Source Interface") : amended,
 guid("{91c3c007-185d-4d78-a751-bfcb31c2c64d}")]
class WHEAErrorSourceMethods : WHEA
{
    [key, read] string InstanceName;
    [read] boolean Active;

    [WmiMethodId(1),
     Implemented,
     DisplayName("Get Error Sources") : amended,
     HeaderName("GET_ALL_ERROR_SOURCES"),
     Description("Returns an array of all hardware error sources") : amended
    ]
    void GetAllErrorSourcesRtn(
        [out] uint32 Status,
        [out] uint32 Count,
        [out] uint32 Length,
        [out, WmiSizeIs("Length")] uint8 ErrorSourceArray[]
        );

    [WmiMethodId(2),
     Implemented,
     DisplayName("Get Error Source Information") : amended,
     HeaderName("GET_ERROR_SOURCE_INFO"),
     Description("Returns information describing the specified hardware error source") : amended
    ]
    void GetErrorSourceInfoRtn(
        [out] uint32 Status,
        [in] uint32 ErrorSourceId,
        [out] uint32 Length,
        [out, WmiSizeIs("Length")] uint8 ErrorSourceInfo[]
        );

    [WmiMethodId(3),
     Implemented,
     DisplayName("Set Error Source Info") : amended,
     HeaderName("SET_ERROR_SOURCE_INFO"),
     Description("Updates the specified error source using the supplied information") : amended
    ]
    void SetErrorSourceInfoRtn(
        [out] uint32 Status,
        [in] uint32 Length,
        [in, WmiSizeIs("Length")] uint8 ErrorSourceInfo[]
        );

    [WmiMethodId(4),
     Implemented,
     DisplayName("Enable Error Source") : amended,
     HeaderName("ENABLE_ERROR_SOURCE"),
     Description("Enables the specified error source") : amended
    ]
    void EnableErrorSourceRtn(
        [out] uint32 Status,
        [in] uint32 ErrorSourceId
        );

    [WmiMethodId(5),
     Implemented,
     DisplayName("Disable Error Source") : amended,
     HeaderName("DISABLE_ERROR_SOURCE"),
     Description("Disables the specified error source") : amended
    ]
    void DisableErrorSourceRtn(
        [out] uint32 Status,
        [in] uint32 ErrorSourceId
        );
};

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


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{39C14290-F036-4999-B8A1-B6F871FB329E}"),
 Description("CMC handling switched from interrupt driver to polling") : amended
]
class MSMCAEvent_SwitchToCMCPolling : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{D5C870CE-4ED0-4fdc-BB54-8B452C18797E}"),
 Description("CPE handling switched from interrupt driver to polling") : amended
]
class MSMCAEvent_SwitchToCPEPolling : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;
};


//
// Define the qualifiers used for the Type property of the MSMCAEvent classes
// The value of the property corresponds to the eventlog type as specified
// in iologmsg.h
//
#define EVENTLOG_MESSAGE_QUALIFIERS \
     Values{ \
            "MCA_WARNING_CACHE", \
            "MCA_ERROR_CACHE", \
            "MCA_WARNING_TLB", \
            "MCA_ERROR_TLB", \
            "MCA_WARNING_CPU_BUS", \
            "MCA_ERROR_CPU_BUS", \
            "MCA_WARNING_REGISTER_FILE", \
            "MCA_ERROR_REGISTER_FILE", \
            "MCA_WARNING_MAS", \
            "MCA_ERROR_MAS", \
            "MCA_WARNING_MEM_UNKNOWN", \
            "MCA_ERROR_MEM_UNKNOWN", \
            "MCA_WARNING_MEM_1_2", \
            "MCA_ERROR_MEM_1_2", \
            "MCA_WARNING_MEM_1_2_5", \
            "MCA_ERROR_MEM_1_2_5", \
            "MCA_WARNING_MEM_1_2_5_4", \
            "MCA_ERROR_MEM_1_2_5_4", \
            "MCA_WARNING_SYSTEM_EVENT", \
            "MCA_ERROR_SYSTEM_EVENT", \
            "MCA_WARNING_PCI_BUS_PARITY", \
            "MCA_ERROR_PCI_BUS_PARITY", \
            "MCA_WARNING_PCI_BUS_PARITY_NO_INFO", \
            "MCA_ERROR_PCI_BUS_PARITY_NO_INFO", \
            "MCA_WARNING_PCI_BUS_SERR", \
            "MCA_ERROR_PCI_BUS_SERR", \
            "MCA_WARNING_PCI_BUS_SERR_NO_INFO", \
            "MCA_ERROR_PCI_BUS_SERR_NO_INFO", \
            "MCA_WARNING_PCI_BUS_MASTER_ABORT", \
            "MCA_ERROR_PCI_BUS_MASTER_ABORT", \
            "MCA_WARNING_PCI_BUS_MASTER_ABORT_NO_INFO", \
            "MCA_ERROR_PCI_BUS_MASTER_ABORT_NO_INFO", \
            "MCA_WARNING_PCI_BUS_TIMEOUT", \
            "MCA_ERROR_PCI_BUS_TIMEOUT", \
            "MCA_WARNING_PCI_BUS_TIMEOUT_NO_INFO", \
            "MCA_ERROR_PCI_BUS_TIMEOUT_NO_INFO", \
            "MCA_WARNING_PCI_BUS_UNKNOWN", \
            "MCA_ERROR_PCI_BUS_UNKNOWN", \
            "MCA_WARNING_PCI_DEVICE", \
            "MCA_ERROR_PCI_DEVICE", \
            "MCA_WARNING_SMBIOS", \
            "MCA_ERROR_SMBIOS", \
            "MCA_WARNING_PLATFORM_SPECIFIC", \
            "MCA_ERROR_PLATFORM_SPECIFIC", \
            "MCA_WARNING_UNKNOWN", \
            "MCA_ERROR_UNKNOWN", \
            "MCA_WARNING_UNKNOWN_NO_CPU", \
            "MCA_ERROR_UNKNOWN_NO_CPU", \
            "MCA_WARNING_CMC_THRESHOLD_EXCEEDED", \
            "MCA_WARNING_CPE_THRESHOLD_EXCEEDED", \
            "MCA_WARNING_CPU_THERMAL_THROTTLED", \
            "MCA_INFO_CPU_THERMAL_THROTTLING_REMOVED", \
            "MCA_WARNING_CPU", \
            "MCA_ERROR_CPU", \
            "MCA_MEMORYHIERARCHY_ERROR", \
            "MCA_TLB_ERROR", \
            "MCA_BUS_ERROR", \
            "MCA_BUS_TIMEOUT_ERROR", \
            "MCA_INTERNALTIMER_ERROR", \
            "MCA_MICROCODE_ROM_PARITY_ERROR", \
            "MCA_EXTERNAL_ERROR", \
            "MCA_FRC_ERROR" \
     }, \
     ValueMap{ \
            "0x8005003C", \
            "0xC005003D", \
            "0x8005003E", \
            "0xC005003F", \
            "0x80050040", \
            "0xC0050041", \
            "0x80050042", \
            "0xC0050043", \
            "0x80050044", \
            "0xC0050045", \
            "0x80050046", \
            "0xC0050047", \
            "0x80050048", \
            "0xC0050049", \
            "0x8005004A", \
            "0xC005004B", \
            "0x8005004C", \
            "0xC005004D", \
            "0x8005004E", \
            "0xC005004F", \
            "0x80050050", \
            "0xC0050051", \
            "0x80050052", \
            "0xC0050053", \
            "0x80050054", \
            "0xC0050055", \
            "0x80050056", \
            "0xC0050057", \
            "0x80050058", \
            "0xC0050059", \
            "0x8005005A", \
            "0xC005005B", \
            "0x8005005C", \
            "0xC005005D", \
            "0x8005005E", \
            "0xC005005F", \
            "0x80050060", \
            "0xC0050061", \
            "0x80050062", \
            "0xC0050063", \
            "0x80050064", \
            "0xC0050065", \
            "0x80050066", \
            "0xC0050067", \
            "0x80050068", \
            "0xC0050069", \
            "0x8005006A", \
            "0xC005006B", \
            "0x8005006D", \
            "0x8005006E", \
            "0x8005006F", \
            "0x40050070", \
            "0x80050071", \
            "0xC0050072", \
            "0xC0050078", \
            "0xC0050079", \
            "0xC005007A", \
            "0xC005007B", \
            "0xC005007C", \
            "0xC005007D", \
            "0xC005007E", \
            "0xC005007F" \
     }, \
     Description("Type of eventlog message") : amended

#define ERROR_SEVERITY_QUALIFIERS \
     Values{"Recoverable", "Fatal", "Correctable"}, \
     ValueMap{ "0", "1", "2" }, \
     Description("Severity of the error record") : amended

#define TRANSACTION_TYPES \
     ValueMap { "0", "1", "2" }, \
     Values { "Instruction Cache", "Data Cache", "Generic" }, \
     Description("MCA transaction type") : amended

#define MEMORY_HIERARCHY_LEVELS \
     ValueMap { "0", "1", "2", "3" }, \
     Values { "Level 0", \
              "Level 1", \
              "Level 2", \
              "Generic" }, \
     Description("MCA memory hierarchy level") : amended

#define REQUEST_TYPES \
     ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8" }, \
     Values { "Generic Error", \
              "Generic Read", \
              "Generic Write", \
              "Data Read", \
              "Data Write", \
              "Instruction Fetch", \
              "Prefetch", \
              "Injection", \
              "Snoop" }, \
     Description("MCA request type") : amended

#define PARTICIPATION_VALUES \
    ValueMap { "0", "1", "2", "3" }, \
    Values { "Local Processor Originated Request", \
             "Local Processor Responded To Request", \
             "Local Processor Observed Error As Third Party", \
             "Generic" }, \
    Description("MCA processor participation description") : amended

#define MEMORY_OR_IO \
    ValueMap { "0", "1", "2", "3" }, \
    Values { "Memory Access", "Reserved", "I/O", "Other transaction" }, \
    Description("Identifies the type of access that caused the error") : amended

//
// NOTE: For all MCA events the first data items must be identical and
//       match whay is in MSMCAEvent_Header.
//

[WMI,
 guid("{6381C27F-C8FA-4da7-8953-B86833736E15}"),
 description("Header for all MSMCA events") : amended
]
class MSMCAEvent_Header
{
    [WmiDataId(1),
     Description("Unique Id for the error record containing this error") : amended
    ]
    uint64 RecordId;

    [WmiDataId(2),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{1ee17050-0039-40f7-9ead-14ad51612cb2}"),
 Description("MCA Bus Error Event") : amended
]
class MSMCAEvent_BusError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

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

    [WmiDataId(2),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     PARTICIPATION_VALUES
    ]
    uint32 Participation;

    [WmiDataId(8),
     MEMORY_HIERARCHY_LEVELS
    ]
    uint32 MemoryHierarchyLevel;

    [WmiDataId(9),
     REQUEST_TYPES
    ]
    uint32 RequestType;

    [WmiDataId(10),
     MEMORY_OR_IO
    ]
    uint32 MemOrIo;

    [WmiDataId(11),
     Description("The address at which the error occurred.")
    ]
    uint64 Address;

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

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

[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{b161eeab-ac03-4c2b-ae7a-5a3768f70e85}"),
 Description("MCA TLB Error Event") : amended
]
class MSMCAEvent_TLBError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

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

    [WmiDataId(2),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     TRASACTION_TYPES
    ]
    uint32 TransactionType;

    [WmiDataId(8),
     MEMORY_HIERARCHY_LEVELS
    ]
    uint32 MemoryHierarchyLevel;

    [WmiDataId(9),
     Description("The address at which the error occurred.")
    ]
    uint64 Address;

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

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

[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{cede75a0-a77f-452b-8f2f-541f926db0f9}"),
 Description("MCA Memory Hierarchy Error Event") : amended
]
class MSMCAEvent_MemoryHierarchyError : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

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

    [WmiDataId(2),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     TRASACTION_TYPES
    ]
    uint32 TransactionType;

    [WmiDataId(8),
     MEMORY_HIERARCHY_LEVELS
    ]
    uint32 MemoryHierarchyLevel;

    [WmiDataId(9),
     REQUEST_TYPES
    ]
    uint32 RequestType;

    [WmiDataId(10),
     Description("The address at which the error occurred.")
    ]
    uint64 Address;

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

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

[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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     Description("Error type of the major error in the section") : amended,
     Values       {"Cache", "TLB", "Bus", "Register File", "Microarchitecture"},
     ValueMap     {    "0",   "1",   "2",             "3",                 "4"},
     DefineValues {"MCACpuCacheError",
                   "MCACpuTlbError",
                   "MCACpuBusError",
                   "MCACpuRegFileError",
                   "MCACpuMSError" }
    ]
    uint32 MajorErrorType;

    //
    // This is valid for cache, tlb and microarchitectural structure errors
    //
    [WmiDataId(8),
     Description("Level of cache, TLB or microarchitectural structure where error occurred (0 indicates first level)") : amended,
     WmiMissingData(-1)
    ]
    uint32 Level;

    //
    // This is valid for cache errors
    //
    [WmiDataId(9),
     Values{ "Unknown or internal error",
             "load",
             "store",
             "instruction fetch or instruction prefetch",
             "data prefetch (both hardware and software)",
             "snoop (coherency check)",
             "cast out (explicit or implicit write-back of a cache line)",
             "move in (cache line fill)"
           } : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7"},
     Description("Type of cache operation that caused the machine check") : amended,
     WmiMissingData(-1)
    ]
    uint32 CacheOp;

    //
    // This is valid for cache errors
    //
    [WmiDataId(10),
     Description("Status of the cache line") : amended,
     Values{"cache line is invalid",
            "cache line is held shares",
            "cache line is held exclusive",
            "cache line is modified"
           } : amended,
     ValueMap{ "0", "1", "2", "3" },
     WmiMissingData(-1)
    ]
    uint32 CacheMesi;

    //
    // This is valid for TLB errors
    //
    [WmiDataId(11),
     Values{ "unknown",
             "TLB access due to load instruction",
             "TLB access due to store instruction",
             "TLB access due to instruction fetch or instruction prefetch",
             "TLB access due to data prefetch (both hardware and software)",
             "TLB shoot down access",
             "TLB probe instruction (probe, tpa)",
             "move in (VHPT fill)"
           } : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7"},
     Description("Type of cache operation that caused the machine check") : amended,
     WmiMissingData(-1)
    ]
    uint32 TLBOp;

    //
    // This is valid for Bus errors
    //
    [WmiDataId(12),
     Values{ "unknown",
             "partial read",
             "partial write",
             "full line read",
             "full line write",
             "implicit or explicit write-back operation",
             "snoop probe",
             "incoming ptc.g",
             "WC transactions"
           } : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Description("Type of Bus transaction that caused the machine check abort") : amended,
     WmiMissingData(-1)
    ]
    uint32 BusType;

    //
    // This is valid for Bus errors
    //
    [WmiDataId(13),
     Description("Bus error severity. The encodings of error severity are platform specific") : amended,
     WmiMissingData(-1)
    ]
    uint32 BusSev;

    //
    // This is valid for RegFile errors
    //
    [WmiDataId(14),
     Values{ "unknown/unclassified",
             "General register (bank 1)",
             "General register (bank 2)",
             "Floating point register",
             "Branch register",
             "Predicate register",
             "Application register",
             "Control register",
             "Region register",
             "Protection key register",
             "Data breakpoint register",
             "Instruction breakpoint register",
             "Performance monitor control register",
             "Performance monitor data register"
           } : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
              "10", "11", "12", "13"},
     Description("Register file identifier") : amended,
     WmiMissingData(-1)
    ]
    uint32 RegFileId;

    //
    // This is valid for RegFile errors
    //
    [WmiDataId(15),
     Values{ "unknown",
             "read",
             "write"
           } : amended,
     ValueMap{"0", "1", "2" },
     Description("Identifies the operation that caused the machine check") : amended,
     WmiMissingData(-1)
    ]
    uint32 RegFileOp;

    //
    // This is valid for Microarchitectural structure errors
    //
    [WmiDataId(16),
     Description("Structure identification. These bits identify the microarchitectural structure where the error occurred.") : amended,
     WmiMissingData(-1)
    ]
    uint32 MSSid;

    [WmiDataId(17),
     Values{ "unknown",
             "read or load",
             "write or store"
           } : amended,
     ValueMap{"0", "1", "2"},
     Description("Type of operation that caused the error") : amended,
     WmiMissingData(-1)
    ]
    uint32 MSOp;

    //
    // This is valid for Microarchitectural structure errors
    //
    [WmiDataId(18),
     Values{ "unknown/unclassified"
           } : amended,
     ValueMap{"0"},
     Description("Identification of the array in the micro architectural structure where the error was generated") : amended,
     WmiMissingData(-1)
    ]
    uint32 MSArrayId;

    //
    // This is valid for Microarchitectural structure errors
    //
    [WmiDataId(19),
     Description("Index ort set of the micro architectural structure where the error was located.") : amended,
     WmiMissingData(-1)
    ]
    uint32 MSIndex;

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

    [WmiDataId(21),
     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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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(8),
     Description("Memory Error Status") : amended
    ]
    uint64 MEM_ERROR_STATUS;

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

    [WmiDataId(10),
     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(11),
     Description("Hardware address of the responder to the transaction") : amended
    ]
    uint64 RESPONDER_ID;

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

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

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

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

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

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

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

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

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

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

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

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

    [WmiDataId(24),
     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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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(8),
     Description("Bus Error Type") : amended
    ]
    uint64 PCI_BUS_ERROR_STATUS;

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

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

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

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

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

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

    [WmiDataId(15),
     Description("PCI Bus Error Types") : amended,
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7"},
     Values{"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(16),
     Description("Designated PCI Bus Identifier encountering error") : amended
    ]
    uint8 PCI_BUS_ID_BusNumber;

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

    [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("{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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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(8),
     Description("Internal Error Code") : amended
    ]
    uint64 PCI_COMP_ERROR_STATUS;

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

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

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

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

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

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

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

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

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

    [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("{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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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(8),
     Description("Timestamp of the event log") : amended
    ]
    uint64 SEL_TIME_STAMP;

    [WmiDataId(9),
     Description("Record ID used for System Event Log access") : amended
    ]
    uint16 SEL_RECORD_ID;

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

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

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

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

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

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

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

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

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

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

    [WmiDataId(20),
     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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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(8),
     Description("Event Type") : 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", "23"},
     Values{"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(9),
     Description("Size of Raw Error Record") : amended
    ]
    uint32 Size;

    [WmiDataId(10),
     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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [WmiDataId(7),
     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_ID 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(8),
     Description("Platform generic error status") : amended
    ]
    uint64 PLATFORM_ERROR_STATUS;

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

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

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

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

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

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

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


[WMI,
 Dynamic,
 Provider("WmiProv"),
 guid("{477B769B-785C-48dd-A02E-57E051BE7B85}"),
 Description("MCA Non Compliant 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),
     ERROR_SEVERITY_QUALIFIERS
    ]
    uint8 ErrorSeverity;

    [WmiDataId(3),
     EVENTLOG_MESSAGE_QUALIFIERS
    ]
    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("If zero then this event is not logged to system eventlog") : amended
    ]
    uint32 LogToEventlog;

    [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("{84E9DDB6-E233-4dfc-988C-7412C8754FEC}"),
 Description("Memory page has been removed") : amended
]
class MSMCAEvent_MemoryPageRemoved : WMIEvent
{
    [key, read]
    string InstanceName;
    boolean Active;

    [WmiDataId(1),
     description("Physical Address of memory paged removed from use by OS") : amended,
     read]
    uint64 PhysicalAddress;
};

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

    [WmiDataId(2),
     read,
     description("Error record contents") : amended,
     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),
     description("Number of error records") : amended,
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     description("Error records") : amended,
     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),
     description("Number of error records") : amended,
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     description("Error records") : amended,
     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),
     description("Number of error records") : amended,
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     description("Error records") : amended,
     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),
     description("Number of error records") : amended,
     read]
    uint32 Count;

    [WmiDataId(2),
     read,
     description("Error records") : amended,
     WmiSizeIs("Count")]
    MSMCAInfo_Entry Records[];
};

//
// 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("{1f177cd9-5955-4721-9f6a-78ebdfaef889}"),
 WmiExpense(1),
 Description("NDIS Notify Filter Removal") : amended]
class MSNdis_NotifyFilterRemoval : WmiEvent
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{0b6d3c89-5917-43ca-b578-d01a7967c41c}"),
 WmiExpense(1),
 Description("NDIS Notify Filter Arrival") : amended]
class MSNdis_NotifyFilterArrival : 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;
};


[WMI, Dynamic, Provider("WMIProv"),
 guid("{9565cd55-3402-4e32-a5b6-2f143f2f2c30}"),
 WmiExpense(1),
 Description("RSS Enabled on this adapter") : amended]
class MSNdis_RSSEnabled : MSNdis
{
    [key, read]
    string              InstanceName;

    [read]
    boolean             Active;

    [read, 
     WmiDataId(1)]    boolean   RSSEnabled;
};


///
///
///     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("Adapter 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 respect 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;
//

};


///
/// NDIS 6 specific GUIDs
///

[WMI,
 guid("{2b1831b2-2216-4ede-a469-9fe3dd6d5a7e}")]
class MSNdis_ObjectHeader : MSNdis
{
        [read, WmiDataId(1)]    uint8  Type;
        [
        read, WmiDataId(2)]     uint8   Revision;
        [
        read, WmiDataId(3)]    uint16  Size;
};

[WMI,
 guid("{e3eac9dd-2fd3-4963-bffd-b4692888c0d4}")]
class MSNdis_WmiMethodHeader : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   PortNumber;
        [
        read, WmiDataId(3)]    uint64  NetLuid;
        [
        read, WmiDataId(4)]    uint64  RequestId;
        [
        read, WmiDataId(5)]    uint32   Timeout;
        [
        read, WmiDataId(6)]    uint32   Padding;
        
};

[WMI,
 guid("{3b5605d8-1aaf-4ff6-85b9-bc5fb973dc54}")]
class MSNdis_WmiSetHeader : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   PortNumber;
        [
        read, WmiDataId(3)]     uint64  NetLuid;
        [
        read, WmiDataId(4)]    uint64  RequestId;
        [
        read, WmiDataId(5)]    uint32   Timeout;
        [
        read, WmiDataId(6)]    uint32   Padding;
};

[WMI,
 guid("{7510bb9d-df70-4f7e-ba07-e29d330b3cc5}")]
class MSNdis_WmiOutputInfo : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]    uint8    SupportedRevision;
        [
        read, WmiDataId(4)]    uint8    Padding1;
        [
        read, WmiDataId(5)]    uint16   Padding2;
        [
        read, WmiDataId(6)]    uint32   DataOffset;
};

[WMI,
 guid("{e7001b59-c3d6-4537-b40e-a163d516e4a3}")]
class MSNdis_WmiEnumAdapter : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   IfIndex;
        [
        read, WmiDataId(3)]     uint64  NetLuid;
        [
        read, WmiDataId(4)]    string  DeviceName;
};


[WMI,
 guid("{5b26b94f-0272-4d4c-8744-bd84be421f3b}")]
class MSNdis_LinkStateData : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  MediaConnectState;
        [
        read, WmiDataId(3)]    uint32   MediaDuplexState;
        [
        read, WmiDataId(4)]    uint64   XmitLinkSpeed;
        [
        read, WmiDataId(5)]    uint64   RcvLinkSpeed;
        [
        read, WmiDataId(6)]    uint32   PauseFunctions;
        [
        read, WmiDataId(7)]    uint32   AutoNegotiationFlags;
};

[WMI,
 guid("{29380131-a312-4400-be0c-53877a41c465}")]
class MSNdis_LinkParameters : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   MediaDuplexState;
        [
        read, WmiDataId(3)]    uint64   XmitLinkSpeed;
        [
        read, WmiDataId(4)]    uint64   RcvLinkSpeed;
        [
        read, WmiDataId(5)]    uint32   PauseFunctions;
        [
        read, WmiDataId(6)]    uint32   AutoNegotiationFlags;
};


[WMI,
 guid("{09f58643-31fb-45b5-852b-09b4d3ff3765}")]
class MSNdis_InterruptModerationParameters : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]    uint32   InterruptModeration;

};

[WMI,
 guid("{8ecc74e1-ba85-482e-afaf-b4f8b087c06b}")]
class MSNdis_StatisticsInfo : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   SupportedStatistics;
        [
        read, WmiDataId(3)]    uint64   ifInDiscards;
        [
        read, WmiDataId(4)]    uint64   ifInErrors;
        [
        read, WmiDataId(5)]    uint64   ifHCInOctets;
        [
        read, WmiDataId(6)]    uint64   ifHCInUcastPkts;
        [
        read, WmiDataId(7)]    uint64   ifHCInMulticastPkts;
        [
        read, WmiDataId(8)]    uint64   ifHCInBroadcastPkts;
        [
        read, WmiDataId(9)]    uint64   ifHCOutOctets;
        [
        read, WmiDataId(10)]    uint64   ifHCOutUcastPkts;
        [
        read, WmiDataId(11)]    uint64   ifHCOutMulticastPkts;
        [
        read, WmiDataId(12)]    uint64   ifHCOutBroadcastPkts;
        [
        read, WmiDataId(13)]    uint64   ifOutErrors;
        [
        read, WmiDataId(14)]    uint64   ifOutDiscards;
        [
        read, WmiDataId(15)]    uint64   ifHCInUcastOctets;
        [
        read, WmiDataId(16)]    uint64   ifHCInMulticastOctets;
        [
        read, WmiDataId(17)]    uint64   ifHCInBroadcastOctets;
        [
        read, WmiDataId(18)]    uint64   ifHCOutUcastOctets;
        [
        read, WmiDataId(19)]    uint64   ifHCOutMulticastOctets;
        [
        read, WmiDataId(20)]    uint64   ifHCOutBroadcastOctets;
};

[WMI,
 guid("{8feae2c6-ee28-469f-8b5d-9f743bab21aa}")]
class MSNdis_PortStateData : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  MediaConnectState;
        [
        read, WmiDataId(3)]    uint64   XmitLinkSpeed;
        [
        read, WmiDataId(4)]    uint64   RcvLinkSpeed;
        [
        read, WmiDataId(5)]    uint32   Direction;
        [
        read, WmiDataId(6)]    uint32   SendControlState;
        [
        read, WmiDataId(7)]    uint32   RcvControlState;
        [
        read, WmiDataId(8)]    uint32   SendAuthorizationState;
        [
        read, WmiDataId(9)]    uint32   RcvAuthorizationState;
        [
        read, WmiDataId(10)]    uint32   Flags;
};
        

[WMI,
 guid("{5c3bda24-8b64-4829-a587-8ce719152fe2}")]
class MSNdis_PortAuthParameters : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   SendControlState;
        [
        read, WmiDataId(3)]    uint32   RcvControlState;
        [
        read, WmiDataId(4)]    uint32   SendAuthorizationState;
        [
        read, WmiDataId(5)]    uint32   RcvAuthorizationState;
};

[WMI,
 guid("{f5b7d202-e594-4aa3-be43-4976833c7840}")]
class MSNdis_PortChar : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  PortNumber;
        [
        read, WmiDataId(3)]    uint32   Flags;
        [
        read, WmiDataId(4)]    uint32   Type;
        [
        read, WmiDataId(5)]     uint32  MediaConnectState;
        [
        read, WmiDataId(6)]    uint64   XmitLinkSpeed;
        [
        read, WmiDataId(7)]    uint64   RcvLinkSpeed;
        [
        read, WmiDataId(8)]    uint32   Direction;
        [
        read, WmiDataId(9)]    uint32   SendControlState;
        [
        read, WmiDataId(10)]    uint32   RcvControlState;
        [
        read, WmiDataId(11)]    uint32   SendAuthorizationState;
        [
        read, WmiDataId(12)]    uint32   RcvAuthorizationState;
};

[WMI,
 guid("{0fee8708-df65-456e-b4ca-fa623266a12a}")]
class MSNdis_PortArray : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]    uint32   NumberOfPorts;
        [
        read, WmiDataId(3)]    uint32   OffsetFirstPort;
        [
        read, WmiDataId(4)]    uint32   ElementSize;
        [
        read, WmiDataId(5), WmiSizeIs("NumberOfPorts")]    MSNdis_PortChar   Port[];

};

[WMI,
 guid("{0573f70f-ded8-401c-8b56-a62bb528c0e2}")]
class MSNdis_PciDeviceProperty : MSNdis
{
        [read, WmiDataId(1)]      MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  DeviceType;
        [
        read, WmiDataId(3)]    uint32   CurrentSpeedAndMode;
        [
        read, WmiDataId(4)]    uint32   CurrentPayloadSize;
        [
        read, WmiDataId(5)]     uint32  MaxPayloadSize;
        [
        read, WmiDataId(6)]    uint32   MaxReadRequestSize;
        [
        read, WmiDataId(7)]    uint32   CurrentLinkSpeed;
        [
        read, WmiDataId(8)]    uint32   CurrentLinkWidth;
        [
        read, WmiDataId(9)]    uint32   MaxLinkSpeed;
        [
        read, WmiDataId(10)]    uint32   MaxLinkWidth;
};

[WMI,
 guid("{d7673b11-e892-4a9d-8bd8-761ff256edd9}")]
class MSNdis_WmiTcpLargeSendOffloadV1_IPv4 : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  MaxOffLoadSize;
        [
        read, WmiDataId(3)]     uint32  MinSegmentCount;
        [
        read, WmiDataId(4)]     uint32  TcpOptions;
        [
        read, WmiDataId(5)]     uint32  IpOptions;
};

[WMI,
 guid("{b9e4e2f9-ee89-4756-b057-38f9d9b59a92}")]
class MSNdis_WmiTcpLargeSendOffloadV1 : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_WmiTcpLargeSendOffloadV1_IPv4  WmiIPv4;
};

[WMI,
 guid("{d63d537a-59c1-4fae-8f9b-cd9fbbecb85a}")]
class MSNdis_WmiTcpIpChecksumOffload_IPv4TransmitReceive : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  IpOptionsSupported;
        [
        read, WmiDataId(3)]     uint32  TcpOptionsSupported;
        [
        read, WmiDataId(4)]     uint32  TcpChecksum;
        [
        read, WmiDataId(5)]     uint32  UdpChecksum;
        [
        read, WmiDataId(6)]     uint32  IpChecksum;
};

[WMI,
 guid("{b9760e75-6662-49e4-aa6c-f028befec8ee}")]
class MSNdis_WmiTcpIpChecksumOffload_IPv6TransmitReceive : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  IpExtensionHeadersSupported;
        [
        read, WmiDataId(3)]     uint32  TcpOptionsSupported;
        [
        read, WmiDataId(4)]     uint32  TcpChecksum;
        [
        read, WmiDataId(5)]     uint32  UdpChecksum;
};

[WMI,
 guid("{189d4015-1b25-4d8e-a4a9-f9eba82197c7}")]
class MSNdis_WmiTcpIpChecksumOffload : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_WmiTcpIpChecksumOffload_IPv4TransmitReceive  IPv4Transmit;
        [
        read, WmiDataId(2)]     MSNdis_WmiTcpIpChecksumOffload_IPv4TransmitReceive  IPv4Receive;
        [
        read, WmiDataId(3)]     MSNdis_WmiTcpIpChecksumOffload_IPv6TransmitReceive  IPv6Transmit;
        [
        read, WmiDataId(4)]     MSNdis_WmiTcpIpChecksumOffload_IPv6TransmitReceive  IPv6Receive;
};

[WMI,
 guid("{f86676b9-d9fa-4d26-95ce-bfbc77d80596}")]
class MSNdis_WmiIPSecOffloadV1_Supported : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  AhEspCombined;
        [
        read, WmiDataId(3)]     uint32  TransportTunnelCombined;
        [
        read, WmiDataId(4)]     uint32  IPv4Options;
        [
        read, WmiDataId(5)]     uint32  Flags;
};

[WMI,
 guid("{29bacfdd-f063-48d8-952c-d3dc93300f15}")]
class MSNdis_WmiIPSecOffloadV1_IPv4AH : MSNdis
{
        [read, WmiDataId(1)]    uint32  Md5;
        [
        read, WmiDataId(2)]     uint32  Sha_1;
        [
        read, WmiDataId(3)]     uint32  Transport;
        [
        read, WmiDataId(4)]     uint32  Tunnel;
        [
        read, WmiDataId(5)]     uint32  Send;
        [
        read, WmiDataId(6)]     uint32  Receive;
};

[WMI,
 guid("{86522023-4536-4b58-a1f4-2538941ace43}")]
class MSNdis_WmiIPSecOffloadV1_IPv4ESP : MSNdis
{
        [read, WmiDataId(1)]    uint32  Des;
        [
        read, WmiDataId(2)]     uint32  Reserved;
        [
        read, WmiDataId(3)]     uint32  TripleDes;
        [
        read, WmiDataId(4)]     uint32  NullEsp;
        [
        read, WmiDataId(5)]     uint32  Transport;
        [
        read, WmiDataId(6)]     uint32  Tunnel;
        [
        read, WmiDataId(7)]     uint32  Send;
        [
        read, WmiDataId(8)]     uint32  Receive;
};


[WMI,
 guid("{4ec63447-2238-43a7-ac33-11c7cc7d8665}")]
class MSNdis_WmiIPSecOffloadV1 : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_WmiIPSecOffloadV1_Supported  WmiSupported;
        [
        read, WmiDataId(2)]     MSNdis_WmiIPSecOffloadV1_IPv4AH     WmiIPv4AH;
        [
        read, WmiDataId(3)]     MSNdis_WmiIPSecOffloadV1_IPv4ESP    WmiIPv4ESP;
};

[WMI,
 guid("{8823d030-fa30-4b73-b339-db19207f0d81}")]
class MSNdis_WmiTcpLargeSendOffloadV2_IPv4 : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  MaxOffLoadSize;
        [
        read, WmiDataId(3)]     uint32  MinSegmentCount;
};

[WMI,
 guid("{a7a9597c-2f8e-410b-9bb3-5c3a50792bfc}")]
class MSNdis_WmiTcpLargeSendOffloadV2_IPv6 : MSNdis
{
        [read, WmiDataId(1)]    uint32  Encapsulation;
        [
        read, WmiDataId(2)]     uint32  MaxOffLoadSize;
        [
        read, WmiDataId(3)]     uint32  MinSegmentCount;
        [
        read, WmiDataId(4)]     uint32  IpExtensionHeadersSupported;
        [
        read, WmiDataId(5)]     uint32  TcpOptionsSupported;
};

[WMI,
 guid("{592977c2-cfbe-462c-b5cf-1a7679fe1cba}")]
class MSNdis_WmiTcpLargeSendOffloadV2 : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_WmiTcpLargeSendOffloadV2_IPv4  WmiIPv4;
        [
        read, WmiDataId(2)]     MSNdis_WmiTcpLargeSendOffloadV2_IPv6  WmiIPv6;
};

[WMI,
 guid("{7a877086-2204-4a8a-92a4-e3e8ab626629}")]
class MSNdis_WmiOffload : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     MSNdis_WmiTcpIpChecksumOffload Checksum;
        [
        read, WmiDataId(3)]     MSNdis_WmiTcpLargeSendOffloadV1 LsoV1;
        [
        read, WmiDataId(4)]     MSNdis_WmiIPSecOffloadV1   IPsecV1;
        [
        read, WmiDataId(5)]     MSNdis_WmiTcpLargeSendOffloadV2 LsoV2;
        [
        read, WmiDataId(6)]     uint32  Flags;
};

[WMI,
 guid("{43fe82d8-3468-497e-9dcf-f8ffc0133744}")]
class MSNdis_TcpOffloadParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint8 IPv4Checksum;
        [
        read, WmiDataId(3)]     uint8 TCPIPv4Checksum;
        [
        read, WmiDataId(4)]     uint8 UDPIPv4Checksum;
        [
        read, WmiDataId(5)]     uint8 TCPIPv6Checksum;
        [
        read, WmiDataId(6)]     uint8 UDPIPv6Checksum;
        [
        read, WmiDataId(7)]     uint8 LsoV1;
        [
        read, WmiDataId(8)]     uint8 IPsec;
        [
        read, WmiDataId(9)]     uint8 LsoV2IPv4;
        [
        read, WmiDataId(10)]     uint8 LsoV2IPv6;
        [
        read, WmiDataId(11)]     uint8 TcpConnectionIPv4;
        [
        read, WmiDataId(12)]     uint8  TcpConnectionIPv6;
        [
        read, WmiDataId(13)]     uint32 Flags;
};

[WMI,
 guid("{93cfcd3f-6228-455c-905e-3ab80a2ff090}")]
class MSNdis_WmiTcpConnectionOffload : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Encapsulation;
        [
        read, WmiDataId(3)]     uint32  SupportIp4;
        [
        read, WmiDataId(4)]     uint32  SupportIp6;
        [
        read, WmiDataId(5)]     uint32  SupportIp6ExtensionHeaders;
        [
        read, WmiDataId(6)]     uint32  SupportSack;
        [
        read, WmiDataId(7)]     uint32  TcpConnectionOffloadCapacity;
        [
        read, WmiDataId(8)]     uint32  Flags;
};

[WMI,
 guid("{34ff16bf-30ca-4a2a-a46d-c7ee74bc3582}")]
class MSNdis_WmiHDSplitCurrentConfig : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  HardwareCapabilities;
        [
        read, WmiDataId(3)]     uint32  CurrentCapabilities;
        [
        read, WmiDataId(4)]     uint32  HDSplitFlags;
        [
        read, WmiDataId(5)]     uint32  HDSplitCombineFlags;
        [
        read, WmiDataId(6)]     uint32  BackfillSize;
        [
        read, WmiDataId(7)]     uint32  MaxHeaderSize;
};

[WMI,
 guid("{1131c56a-0a5a-4d79-8dde-1e6f178005ee}")]
class MSNdis_HDSplitParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32 HDSplitCombineFlags;
};

[WMI,
 guid("{f7a4960a-ace3-44dc-b51e-72e05c5eafa8}")]
class MSNdis_WmiReceiveScaleCapabilities : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  CapabilitiesFlags;
        [
        read, WmiDataId(3)]     uint32  NumberOfInterruptMessages;
        [
        read, WmiDataId(4)]     uint32  NumberOfReceiveQueues;
};

[WMI,
 guid("{146360a3-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterCapabilities : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  EnabledFilterTypes;
        [
        read, WmiDataId(4)]     uint32  EnabledQueueTypes;
        [
        read, WmiDataId(5)]     uint32  NumQueues;
        [
        read, WmiDataId(6)]     uint32  SupportedQueueProperties;
        [
        read, WmiDataId(7)]     uint32  SupportedFilterTests;
        [
        read, WmiDataId(8)]     uint32  SupportedHeaders;
        [
        read, WmiDataId(9)]     uint32  SupportedMacHeaderFields;
        [
        read, WmiDataId(10)]    uint32  MaxMacHeaderFilters;
        [
        read, WmiDataId(11)]    uint32  MaxQueueGroups;
        [
        read, WmiDataId(12)]    uint32  MaxQueuesPerQueueGroup;
        [
        read, WmiDataId(13)]    uint32  MinLookaheadSplitSize;
        [
        read, WmiDataId(14)]    uint32  MaxLookaheadSplitSize;
};

[WMI,
 guid("{146360a4-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterGlobalParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  EnabledFilterTypes;
        [
        read, WmiDataId(4)]     uint32  EnabledQueueTypes;        
};

[WMI,
 guid("{146360a5-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_CountedString : MSNdis
{
        [read, WmiDataId(1)]    uint16  Length;
        [
        read, WmiDataId(2)]     char16  String[257];
};

[WMI,
 guid("{146360a9-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterInfo : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  FilterType;
        [
        read, WmiDataId(4)]     uint32  FilterId;
};

[WMI, Dynamic, Provider("WMIProv"),
guid("{146360aa-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterInfoArray : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, write, WmiDataId(2)]     uint32   QueueId;        
        [
        read, WmiDataId(3)]     uint32   FirstElementOffset;
        [
        read, WmiDataId(4)]     uint32   NumElements;
        [
        read, WmiDataId(5)]     uint32   ElementSize;
        [
        read, WmiDataId(6), WmiSizeIs("NumElements")]    MSNdis_ReceiveFilterInfo   Filter[];
};

[WMI,
 guid("{146360ab-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterFieldParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  FrameHeader;
        [
        read, WmiDataId(4)]     uint32  ReceiveFilterTest;
        [
        read, WmiDataId(5)]     uint32  MacHeaderField;
        [
        read, WmiDataId(6)]     uint8   FieldByteArrayValue[16];
        [
        read, WmiDataId(7)]     uint8   ResultByteArrayValue[16];
};

[WMI, Dynamic, Provider("WMIProv"),
guid("{146360ac-88dd-11dd-94b8-001d09162bc3}")]
class MSNdis_ReceiveFilterParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32   Flags;
        [
        read, WmiDataId(3)]     uint32   FilterType;
        [
        read, WmiDataId(4)]     uint32   QueueId;
        [
        read, write, WmiDataId(5)]     uint32   FilterId;
        [
        read, WmiDataId(6)]     uint32   FieldParametersArrayOffset;
        [
        read, WmiDataId(7)]     uint32   FieldParametersArrayNumElements;
        [
        read, WmiDataId(8)]     uint32   FieldParametersArrayElementSize;
        [
        read, WmiDataId(9)]     uint32   RequestedFilterIdBitCount;
        [
        read, WmiDataId(10), WmiSizeIs("FieldParametersArrayNumElements")]    MSNdis_ReceiveFilterFieldParameters   FieldParameters[];

};

[WMI,
 guid("{db80dd1c-59ae-48e7-b7ec-f9be2c4b8cb0}")]
class MSNdis_NicSwitchCapabilities : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  NdisReserved1;
        [
        read, WmiDataId(4)]     uint32  NumTotalMacAddresses;
        [
        read, WmiDataId(5)]     uint32  NumMacAddressesPerPort;
        [
        read, WmiDataId(6)]     uint32  NumVlansPerPort;
        [
        read, WmiDataId(7)]     uint32  NdisReserved2;
        [
        read, WmiDataId(8)]     uint32  NdisReserved3;
};

[WMI, 
 guid("{f786fbd5-c049-11dd-b885-001d09162bc3}")]
class MSNdis_GroupAffinity : MSNdis
{
        [read, WmiDataId(1)]    uint64  Mask;
        [
        read, WmiDataId(2)]     uint16  Group;
        [
        read, WmiDataId(3)]     uint16  Reserved[3];
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{f786fbd6-c049-11dd-b885-001d09162bc3}")]
class MSNdis_ReceiveQueueParameters : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  QueueType;
        [
        read, write, WmiDataId(4)]     uint32  QueueId;
        [
        read, WmiDataId(5)]     uint32  QueueGroupId;
        [
        read, WmiDataId(6)]     MSNdis_GroupAffinity  ProcessorAffinity;
        [
        read, WmiDataId(7)]     uint32  NumSuggestedReceiveBuffers;
        [
        read, WmiDataId(8)]     uint32  MSIXTableEntry;
        [
        read, WmiDataId(9)]     uint32  LookaheadSize;
        [
        read, WmiDataId(10)]     MSNdis_CountedString  VmName;
        [
        read, WmiDataId(11)]     MSNdis_CountedString  QueueName;        
};

[WMI,
 guid("{f786fbd7-c049-11dd-b885-001d09162bc3}")]
class MSNdis_ReceiveQueueInfo : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32  Flags;
        [
        read, WmiDataId(3)]     uint32  QueueType;
        [
        read, WmiDataId(4)]     uint32  QueueId;
        [
        read, WmiDataId(5)]     uint32  QueueGroupId;
        [
        read, WmiDataId(6)]     uint32  QueueState;
        [
        read, WmiDataId(7)]     MSNdis_GroupAffinity  ProcessorAffinity;        
        [
        read, WmiDataId(8)]     uint32  NumSuggestedReceiveBuffers;
        [
        read, WmiDataId(9)]     uint32  MSIXTableEntry;
        [
        read, WmiDataId(10)]     uint32  LookaheadSize;        
        [
        read, WmiDataId(11)]     MSNdis_CountedString  VmName;
        [
        read, WmiDataId(12)]     MSNdis_CountedString  QueueName;                
};

[WMI,  
 guid("{f786fbd8-c049-11dd-b885-001d09162bc3}")]
class MSNdis_ReceiveQueueInfoArray : MSNdis
{
        [read, WmiDataId(1)]    MSNdis_ObjectHeader  Header;
        [
        read, WmiDataId(2)]     uint32   FirstElementOffset;
        [
        read, WmiDataId(3)]     uint32   NumElements;
        [
        read, WmiDataId(4)]     uint32   ElementSize;
        [
        read, WmiDataId(5), WmiSizeIs("NumElements")]    MSNdis_ReceiveQueueInfo   Queue[];
};


[WMI, Dynamic, Provider("WMIProv"), guid("{ba1f4c14-a945-4762-b916-0b5515b6f43a}"),

  WmiExpense(1),
  Description("NDIS Query Link State") : amended]
class  MSNdis_LinkState : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Link State"):amended
            ] void WmiQueryLinkState([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Link State of the adapter"):amended
                                     ] MSNdis_LinkStateData    LinkState);

};


[WMI, Dynamic, Provider("WMIProv"), guid("{d9c8eea5-f16e-467c-84d5-6345a22ce213}"),

  WmiExpense(1),
  Description("NDIS Query Interrupt Moderation") : amended]
class  MSNdis_QueryInterruptModeration : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Interrupt Moderation"):amended
            ] void WmiQueryInterruptModeration([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Interrupt Moderation of the adapter"):amended
                                     ] MSNdis_InterruptModerationParameters    InterruptModeration);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{d789adfa-9c56-433b-ad01-7574f3cedbe9}"),

  WmiExpense(1),
  Description("NDIS Set Interrupt Moderation") : amended]
class  MSNdis_SetInterruptModeration : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Set Interrupt Moderation"):amended
            ] void WmiSetInterruptModeration([in, Description("NDIS WMI Common Method Header"):amended
                                     ] MSNdis_WmiMethodHeader     MethodHeader,
                                     [in, Description("Interrupt Moderation Parameters to set"):amended
                                     ] MSNdis_InterruptModerationParameters    InterruptModeration,
                                     [out, Description("Output from Setting Interrupt Moderation of the adapter"):amended
                                     ] MSNdis_WmiOutputInfo    OutputInfo);
};

[WMI, Dynamic, Provider("WMIProv"), guid("{8c7d3579-252b-4614-82c5-a650daa15049}"),

  WmiExpense(1),
  Description("NDIS Set Link Parameters") : amended]
class  MSNdis_SetLinkParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Set Link Parameters"):amended
            ] void WmiSetLinkParameters([in, Description("NDIS WMI Common Method Header"):amended
                                     ] MSNdis_WmiMethodHeader     MethodHeader,
                                     [in, Description("Link Parameters to set"):amended
                                     ] MSNdis_LinkParameters    LinkParameters,
                                     [out, Description("Output from Setting Link Parameters of the adapter"):amended
                                     ] MSNdis_WmiOutputInfo    OutputInfo);
};

[WMI, Dynamic, Provider("WMIProv"), guid("{368c45b5-c129-43c1-939e-7edc2d7fe621}"),

  WmiExpense(1),
  Description("NDIS Query Statistics Info") : amended]
class  MSNdis_QueryStatisticsInfo : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Statistics Info"):amended
            ] void WmiQueryStatisticsInfo([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Statistics Info of the adapter"):amended
                                     ] MSNdis_StatisticsInfo   StatisticsInfo);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{6fbf2a5f-8b8f-4920-8143-e6c460f52524}"),

  WmiExpense(1),
  Description("NDIS Query Port State") : amended]
class  MSNdis_QueryPortState : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Port State"):amended
            ] void WmiQueryPortState([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Port State of a sub-Interface of the adapter"):amended
                                     ] MSNdis_PortStateData   PortState);

};


[WMI, Dynamic, Provider("WMIProv"), guid("{f1d6abe8-15e4-4407-81b7-6b830c777cd9}"),

  WmiExpense(1),
  Description("NDIS Query Ports on an Adapter") : amended]
class  MSNdis_EnumeratePorts : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Ports on an Adapter"):amended
            ] void WmiEnumeratePorts([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Ports activated on the adapter"):amended
                                     ] MSNdis_PortArray    Ports);

};


[WMI, Dynamic, Provider("WMIProv"), guid("{aab6ac31-86fb-48fb-8b48-63db235ace16}"),

  WmiExpense(1),
  Description("NDIS Set Port Auth Parameters on a Port") : amended]
class  MSNdis_SetPortParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Set Port Auth Parameters on a Port"):amended
            ] void WmiSetPortParameters([in, Description("NDIS WMI Common Method Header"):amended
                                     ] MSNdis_WmiMethodHeader      MethodHeader,
                                     [in, Description("Set Port Auth Parameters on a Port"):amended
                                     ] MSNdis_PortAuthParameters   PortParameters,
                                     [out, Description("Result from Setting Port Auth Parameters"):amended
                                     ] MSNdis_WmiOutputInfo   OutputInfo);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{aa39f5ab-e260-4d01-82b0-b737c880ea05}"),

  WmiExpense(1),
  Description("NDIS Query PCI Device Custom Property") : amended]
class  MSNdis_QueryPciDeviceCustomProperty : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query PCI Device Custom Property"):amended
            ] void WmiQueryPciDeviceCustomProperty([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("PCI Device Custom Property of the adapter"):amended
                                     ] MSNdis_PciDeviceProperty    PciDeviceProperty);

};


[WMI, Dynamic, Provider("WMIProv"), guid("{16716917-4306-4be4-9b5a-3809ae44b125}"),

 WmiExpense(1),
 Description("NDIS Enumerate Adapter EX.") : amended]
class  MSNdis_EnumerateAdapterEx : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("The Information about the Adapter.") : amended,
                WmiDataId(1)]   MSNdis_WmiEnumAdapter   EnumerateAdapter;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{68542fed-5c74-461e-8934-91c6f9c60960}"),

  WmiExpense(1),
  Description("NDIS Query TCP Offload Current Config") : amended]
class  MSNdis_TcpOffloadCurrentConfig : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Current Offload Configuration"):amended
            ] void WmiQueryCurrentOffloadConfig([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Current Offload Configuration of the adapter"):amended
                                     ] MSNdis_WmiOffload    Offload);
};


[WMI, Dynamic, Provider("WMIProv"), guid("{cd5f1102-590f-4ada-ab65-5b31b1dc0172}"),

  WmiExpense(1),
  Description("NDIS Query TCP Offload Hardware Config") : amended]
class  MSNdis_TcpOffloadHardwareConfig : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Hardware Offload Configuration"):amended
            ] void WmiQueryHardwareOffloadConfig([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Headware Offload Configuration of the adapter"):amended
                                     ] MSNdis_WmiOffload    Offload);
};


[WMI, Dynamic, Provider("WMIProv"), guid("{8ead9a22-7f69-4bc6-949a-c8187b074e61}"),

  WmiExpense(1),
  Description("NDIS Set TCP Offload Parameters") : amended]
class  MSNdis_SetTcpOffloadParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Set TCP Offload Parameters"):amended
            ] void WmiSetTcpOffloadParameters([in, Description("NDIS WMI Common Method Header"):amended
                                     ] MSNdis_WmiMethodHeader      MethodHeader,
                                     [in, Description("Set TCP Offload Parameters"):amended
                                     ] MSNdis_TcpOffloadParameters   TcpOffloadParameters,
                                     [out, Description("Result from Setting TCP Offload Parameters"):amended
                                     ] MSNdis_WmiOutputInfo   OutputInfo);

};


[WMI, Dynamic, Provider("WMIProv"), guid("{2ee6aef1-0851-458b-bf0d-792343d1cde1}"),

  WmiExpense(1),
  Description("NDIS Query TCP Connection Offload Current Config") : amended]
class  MSNdis_TcpConnectionOffloadCurrentConfig : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query TCP Connection Offload Current Configuration"):amended
            ] void WmiQueryTcpConnectionOffloadCurrentConfig(
                                     [in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("TCP Connection Offload Current Configuration of the adapter"):amended
                                     ] MSNdis_WmiTcpConnectionOffload    Offload);
};

[WMI, Dynamic, Provider("WMIProv"), guid("{8ce71f2c-d63a-4390-a487-18fa47262ceb}"),

  WmiExpense(1),
  Description("NDIS Query TCP Connection Offload Hardware Config") : amended]
class  MSNdis_TcpConnectionOffloadHardwareConfig : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query TCP Connection Offload Hardware Configuration"):amended
            ] void WmiQueryTcpConnectionOffloadHardwareConfig(
                                     [in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("TCP Connection Offload Hardware Configuration of the adapter"):amended
                                     ] MSNdis_WmiTcpConnectionOffload    Offload);
};

[WMI, Dynamic, Provider("WMIProv"), guid("{26c28774-4252-48fe-a610-a58a398c0eb1}"),

  WmiExpense(1),
  Description("NDIS Query RSS Capabilities") : amended]
class  MSNdis_ReceiveScaleCapabilities : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query RSS Capabilities"):amended
            ] void WmiQueryReceiveScaleCapabilities(
                                     [in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("RSS capabilities of the adapter"):amended
                                     ] MSNdis_WmiReceiveScaleCapabilities    RssCaps);
};

//
// GUID_NDIS_HD_SPLIT_CURRENT_CONFIG
//

[WMI, Dynamic, Provider("WMIProv"), guid("{81d1303c-ab00-4e49-80b1-5e6e0bf9be53}"),

  WmiExpense(1),
  Description("NDIS Query Header/Data Split Current Config") : amended]
class  MSNdis_HDSplitCurrentConfig : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Header/Data split Current Config"):amended
            ] void WmiQueryHDSplitCurrentConfig(
                                     [in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Header/Data split Current Config of the adapter"):amended
                                     ] MSNdis_WmiHDSplitCurrentConfig    HdSplitCurrentConfig);
};

//
// GUID_NDIS_HD_SPLIT_PARAMETERS
//

[WMI, Dynamic, Provider("WMIProv"), guid("{8c048bea-2913-4458-b68e-17f6c1e5c60e}"),

  WmiExpense(1),
  Description("NDIS Set Header/Data Split Parameters") : amended]
class  MSNdis_SetHDSplitParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Set Header/Data split Parameters"):amended
            ] void WmiSetHDSplitParameters([in, Description("NDIS WMI Common Method Header"):amended
                                     ] MSNdis_WmiMethodHeader      MethodHeader,
                                     [in, Description("Set Header/Data Split Parameters"):amended
                                     ] MSNdis_HDSplitParameters   HDSplitParameters,
                                     [out, Description("Result from Setting Header/ Split Parameters"):amended
                                     ] MSNdis_WmiOutputInfo   OutputInfo);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{899e7782-035b-43f9-8bb6-2b58971612e5}"),

  WmiExpense(1),
  Description("NDIS Query Physical Medium Type Ex") : amended]
class  MSNdis_QueryPhysicalMediumTypeEx : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query NDIS Physical Medium Type (Ex) of the NIC"):amended
            ] void WmiQueryPhysicalMediumTypeEx([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Physical Medium type (Ex) of the adapter"):amended
                                     ] uint32    NdisPhysicalMediumTypeEx);

};

//
// Guids for NDIS Receive Filters
//
[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c1419-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Query Receive Filter Hardware Capabilities") : amended]
class  MSNdis_QueryReceiveFilterHardwareCapabilities : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Receive Filter Hardware capabilities"):amended
            ] void WmiQueryReceiveFilterHardwareCapabilities([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Receive filter hardware capabilities of the adapter"):amended
                                     ] MSNdis_ReceiveFilterCapabilities    ReceiveFilterHardwareCapabilities);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c141a-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Query Receive Filter Global Parameters") : amended]
class  MSNdis_QueryReceiveFilterGlobalParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Receive Filter Global Parameters"):amended
            ] void WmiQueryReceiveFilterGlobalParameters([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Receive filter global parameters of the adapter"):amended
                                     ] MSNdis_ReceiveFilterGlobalParameters    ReceiveFilterGlobalParameters);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c141d-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Enumerate Receive Filters") : amended]
class  MSNdis_EnumerateReceiveFilters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Enumerate Receive Filters"):amended
            ] void WmiEnumReceiveFilters([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [in, out, Description("Enumeration of Receive Filters on a queue"):amended
                                     ] MSNdis_ReceiveFilterInfoArray    ReceiveFilterInfoArray);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c141e-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Receive Filter Parameters") : amended]
class  MSNdis_QueryReceiveFilterParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Receive Filter Parameters"):amended
            ] void WmiQueryReceiveFilterParameters([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [in, out, Description("Receive Filter Parameters"):amended
                                     ] MSNdis_ReceiveFilterParameters    ReceiveFilterParameters);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{4054e80f-2bc1-4ccc-b033-4abc0c4a1e8c}"),

  WmiExpense(1),
  Description("NDIS Query Receive Filter Current Capabilities") : amended]
class  MSNdis_QueryReceiveFilterCurrentCapabilities : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Receive Filter Current capabilities"):amended
            ] void WmiQueryReceiveFilterCurrentCapabilities([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("Receive filter current capabilities of the adapter"):amended
                                     ] MSNdis_ReceiveFilterCapabilities    ReceiveFilterCurrentCapabilities);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{37cab40c-d1e8-4301-8c1d-58465e0c4c0f}"),

  WmiExpense(1),
  Description("NDIS Query NIC Switch Hardware Capabilities") : amended]
class  MSNdis_QueryNicSwitchHardwareCapabilities : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query NIC Switch Hardware Capabilities"):amended
            ] void WmiQueryNICSwitchHardwareCapabilities([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("NIC Switch hardware capabilities of the adapter"):amended
                                     ] MSNdis_NicSwitchCapabilities    NicSwitchHardwareCapabilities);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{e76fdaf3-0be7-4d95-87e9-5aead4b590e9}"),

  WmiExpense(1),
  Description("NDIS Query NIC Switch Current Capabilities") : amended]
class  MSNdis_QueryNicSwitchCurrentCapabilities : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query NIC Switch Current Capabilities"):amended
            ] void WmiQueryNICSwitchCurrentCapabilities([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [out, Description("NIC Switch Current capabilities of the adapter"):amended
                                     ] MSNdis_NicSwitchCapabilities    NicSwitchCurrentCapabilities);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c141c-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Receive Queue Parameters") : amended]
class  MSNdis_QueryReceiveQueueParameters : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Query Receive Queue Parameters"):amended
            ] void WmiQueryReceiveQueueParameters([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [in, out, Description("Receive Queue Parameters"):amended
                                     ] MSNdis_ReceiveQueueParameters    ReceiveQueueParameters);

};

[WMI, Dynamic, Provider("WMIProv"), guid("{3f2c141b-83bc-11dd-94b8-001d09162bc3}"),

  WmiExpense(1),
  Description("NDIS Enumerate Receive Queues") : amended]
class  MSNdis_EnumerateReceiveQueues : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


        [WmiMethodId(1),
         Implemented,
          Description("Enumerate Receive Queues"):amended
            ] void WmiEnumReceiveQueues([in, Description("NDIS WMI Method Common Header"):amended
                                     ] MSNdis_WmiMethodHeader Header,
                                     [in, out, Description("Enumeration of Receive queues on a miniport"):amended
                                     ] MSNdis_ReceiveQueueInfoArray    ReceiveQueueInfoArray);

};



///
///
///     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,
                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 up to 32 characters long.") : amended]
class  MSNdis_80211_ServiceSetIdentifier : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                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,
                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,
                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,
                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,
                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,
                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,
                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,
                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,
                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,
                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-97eb-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,
                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,
                WmiDataId(1)]   MSNdis_80211_ConfigurationInfo      Ndis80211Config;
};


///
///     OID_802_11_STATISTICS:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{42bb73b0-2129-11d4-97eb-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-97eb-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")]
                                uint8      KeyMaterial[];
};


///
///     OID_802_11_REMOVE_WEP:
///
[WMI, Dynamic, Provider("WMIProv"), guid("{433c345c-2129-11d4-97eb-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-97eb-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-97eb-00c04f79c403}"),

 WmiExpense(1),
 Description("NDIS 802.11 Authentication Mode") : amended]
class  MSNdis_80211_AuthenticationMode : MSNdis
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                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,
                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,
                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;
};


///
///  Embedded class definition for NDIS_PM_ADMIN_CONFIG_STATE
///
[WMI, guid("{0cffd0fc-8333-4000-9a3b-200735d698f9}")]
class  MSNdis_PMAdminConfigState : MSNdis
{
    [Values{"NdisPMAdminConfigStateUnspecified",
            "NdisPMAdminConfigStateDisabled",
            "NdisPMAdminConfigStateEnabled"},
    ValueMap{"0",
             "1",
             "2"},
    WmiDataId(1)]      
    uint32      NdisPMAdminConfigState;
};

///
///  Embedded class definition for NDIS_WMI_PM_ADMIN_CONFIG
///
[WMI, guid("{492dc449-13d9-4bd6-89d4-96e3534e6a05}")]
class  MSNdis_PMAdminConfigParam : MSNdis
{ 
    [WmiDataId(1)]
    MSNdis_ObjectHeader         Header;    
    [WmiDataId(2)]
    MSNdis_PMAdminConfigState   WakeOnPattern;
    [WmiDataId(3)]
    MSNdis_PMAdminConfigState   WakeOnMagicPacket;
    [WmiDataId(4)]
    MSNdis_PMAdminConfigState   DeviceSleepOnDisconnect;
    [WmiDataId(5)]
    MSNdis_PMAdminConfigState   PMARPOffload;
    [WmiDataId(6)]
    MSNdis_PMAdminConfigState   PMNDOffload;
    [WmiDataId(7)]
    MSNdis_PMAdminConfigState   PMWiFiRekeyOffload;
};

///
/// GUID_NDIS_PM_ADMIN_CONFIG
///
[WMI, Dynamic, Provider("WMIProv"),
 guid("{1528D111-708A-4ca4-9215-C05771161CDA}"),
 Description("Control power management related standardized keywords")]
class MSNdis_PMAdminConfig : MSNdis
{
    [key, read]
    string              InstanceName;
    [read]
    boolean             Active;

    [read, write, WmiDataId(1)]      
    MSNdis_PMAdminConfigParam   PMAdminConfigParam;
};

///
///  Embedded class definition for NDIS_PM_CAPABILITY_STATE
///
[WMI, guid("{C1CC6857-1A26-4f6d-AB98-291F0C3BBD4C}")]
class  MSNdis_PMCapabilityState : MSNdis
{
    [Values{"NdisPMAdminConfigUnsupported",
            "NdisPMAdminConfigInactive",
            "NdisPMAdminConfigActive"},
    ValueMap{"0",
             "1",
             "2"},
    WmiDataId(1)]      
    uint32      NdisPMCapabilityState;
};

///
///  Embedded class definition for NDIS_WMI_PM_ACTIVE_CAPABILITIES
///
[WMI, guid("{CCCB122D-D5C4-4ee1-8001-B8AD6D3CE876}")]
class  MSNdis_PMCapabilitiesParam : MSNdis
{
    [WmiDataId(1)]
    MSNdis_ObjectHeader         Header;    
    [WmiDataId(2)]
    MSNdis_PMCapabilityState   WakeOnPattern;
    [WmiDataId(3)]
    MSNdis_PMCapabilityState   WakeOnMagicPacket;
    [WmiDataId(4)]
    MSNdis_PMCapabilityState   DeviceSleepOnDisconnect;
    [WmiDataId(5)]
    MSNdis_PMCapabilityState   PMARPOffload;
    [WmiDataId(6)]
    MSNdis_PMCapabilityState   PMNDOffload;
    [WmiDataId(7)]
    MSNdis_PMCapabilityState   PMWiFiRekeyOffload;
};

///
/// GUID_NDIS_PM_ACTIVE_CAPABILITIES
///
[WMI, Dynamic, Provider("WMIProv"),
 guid("{B2CF76E3-B3AE-4394-A01F-338C9870E939}"),
 Description("Query power management active capabilities")]
class MSNdis_PMCapabilities : MSNdis
{
    [key, read]
    string              InstanceName;
    [read]
    boolean             Active;

    [read, WmiDataId(1)]      
    MSNdis_PMCapabilitiesParam   PMCapabilitiesParam;
};


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

[WMI, Dynamic, Provider("WMIProv"),
 guid("{5f81cfd0-f046-4342-61af-895acedaefd9}"),

 WmiExpense(1),
 Description("NDIS Device Power On Notification") : amended]
class  MSNdis_StatusDevicePowerOn  : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
     Description("Name of device powered on") : amended,
     WmiDataId(1)]    string Device;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{81bc8189-b026-46ab-64b9-f182e342934e}"),

 WmiExpense(1),
 Description("NDIS Device Power Off Notification") : amended]
class  MSNdis_StatusDevicePowerOff  : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
     Description("Name of device powered off") : amended,
     WmiDataId(1)]    string Device;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{2b440188-92ac-4f60-9b2d-20a30cbb6bbe}"),

 WmiExpense(1),
 Description("NDIS Device Power On Ex Notification") : amended]
class  MSNdis_StatusDevicePowerOnEx  : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
     Description("Name of device powered on") : amended,
     WmiDataId(1)]    string Device;
};

[WMI, Dynamic, Provider("WMIProv"),
 guid("{4159353c-5cd7-42ce-8fe4-a45a2380cc4f}"),

 WmiExpense(1),
 Description("NDIS Device Power Off Ex Notification") : amended]
class  MSNdis_StatusDevicePowerOffEx  : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
     Description("Name of device powered off") : amended,
     WmiDataId(1)]    string Device;
};

[WMI, Dynamic, Provider("WMIProv"), guid("{45049fc6-54d8-40c8-9c3d-b011c4e715bc}"),

 WmiExpense(1),
 Description("NDIS Status Task Offload Change") : amended]
class  MSNdis_StatusTaskOffloadChange : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for task offload change indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("New Task Offload Capabilities.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    TaskOffloadCapabilities[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{d47c5407-2e75-46dd-8146-1d7ed2d6ab1d}"),

 WmiExpense(1),
 Description("NDIS Status Packet Filter Change") : amended]
class  MSNdis_StatusPacketFilterChange : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;


    [
    read,
                Description("Number of bytes for packet filter status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Packet Filter status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisPacketFilterStatusIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{ca8a56f9-ce81-40e6-a70f-a067a476e9e9}"),

 WmiExpense(1),
 Description("NDIS Status Network Change") : amended]
class  MSNdis_StatusNetworkChange : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;
    [
    read,
                Description("Number of bytes for network change status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Network Change status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisNetworkChangeStatusIndication[];

};

[WMI, Dynamic, Provider("WMIProv"), guid("{f917b663-845e-4d3d-b6d4-15eb27af81c5}"),

 WmiExpense(1),
 Description("NDIS Status Operational Status") : amended]
class  MSNdis_StatusOperationalStatus : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for operational status status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Operational Status status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisOperationalStatusStatusIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{64c6f797-878c-4311-9246-65dba89c3a61}"),

 WmiExpense(1),
 Description("NDIS Status Link State Change") : amended]
class  MSNdis_StatusLinkState : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for link state status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Link State status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisLinkStateStatusIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{1dac0dfe-43e5-44b7-b759-7bf46de32e81}"),

 WmiExpense(1),
 Description("NDIS Status Port State Change") : amended]
class  MSNdis_StatusPortState : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for port state status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Port State status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisPortStateStatusIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{aaacfca7-954a-4632-a16e-a8a63793a9e5}"),

 WmiExpense(1),
 Description("NDIS 6 Status Media Specific Status Indication") : amended]
class  MSNdis_StatusMediaSpecificIndicationEx : 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[];
};

//
// GUID_NDIS_STATUS_HD_SPLIT_CURRENT_CONFIG
//

[WMI, Dynamic, Provider("WMIProv"), guid("{6c744b0e-ee9c-4205-90a2-015f6d65f403}"),

 WmiExpense(1),
 Description("NDIS Status Header/Data Split Current Config") : amended]
class  MSNdis_StatusHDSplitCurrentConfig : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for header/data split current config change indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("New Header/Data split configuration.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    HDSplitCurrentConfig[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{8500591e-a0c7-4efb-9342-b674b002cbe6}"),
 WmiExpense(1),
 Description("NDIS Dot11 Scan Confirm Status Indication") : amended]
class  MSNdis_StatusDot11ScanConfirm : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 scan confirm status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Scan Confirm status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11ScanConfirmIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{1d6560ec-8e48-4a3e-9fd5-a01b698db6c5}"),
 WmiExpense(1),
 Description("NDIS Dot11 MPDU Max Length Change Status Indication") : amended]
class  MSNdis_StatusDot11MPDUMaxLengthChange : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 MPDU max length change status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 MPDU Max Length Change status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11MPDUMaxLengthChangeIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{3927843b-6980-4b48-b15b-4de50977ac40}"),
 WmiExpense(1),
 Description("NDIS Dot11 Association Start Status Indication") : amended]
class  MSNdis_StatusDot11AssociationStart : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 association start status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Association Start status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11AssociationStartIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{458bbea7-45a4-4ae2-b176-e51f96fc0568}"),
 WmiExpense(1),
 Description("NDIS Dot11 Association Completion Status Indication") : amended]
class  MSNdis_StatusDot11AssociationCompletion : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 association completion status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Association Completion status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11AssociationCompletionIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{7b74299d-998f-4454-ad08-c5af28576d1b}"),
 WmiExpense(1),
 Description("NDIS Dot11 Connection Start Status Indication") : amended]
class  MSNdis_StatusDot11ConnectionStart : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 connection start status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Connection Start status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11ConnectionStartIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{96efd9c9-7f1b-4a89-bc04-3e9e271765f1}"),
 WmiExpense(1),
 Description("NDIS Dot11 Connection Completion Status Indication") : amended]
class  MSNdis_StatusDot11ConnectionCompletion : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 connection completion status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Connection Completion status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11ConnectionCompletionIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{b2412d0d-26c8-4f4e-93df-f7b705a0b433}"),
 WmiExpense(1),
 Description("NDIS Dot11 Roaming Start Status Indication") : amended]
class  MSNdis_StatusDot11RoamingStart : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 roaming start status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Roaming Start status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11RoamingStartIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{dd9d47d1-282b-41e4-b924-66368817fcd3}"),
 WmiExpense(1),
 Description("NDIS Dot11 Roaming Completion Status Indication") : amended]
class  MSNdis_StatusDot11RoamingCompletion : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 roaming completion status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Roaming Completion status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11RoamingCompletionIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{3fbeb6fc-0fe2-43fd-b2ad-bd99b5f93e13}"),
 WmiExpense(1),
 Description("NDIS Dot11 Disassociation Status Indication") : amended]
class  MSNdis_StatusDot11Disassociation : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 disassociation status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Disassociation status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11DisassociationIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{442c2ae4-9bc5-4b90-a889-455ef220f4ee}"),
 WmiExpense(1),
 Description("NDIS Dot11 TKIPMIC Failure Status Indication") : amended]
class  MSNdis_StatusDot11TkipmicFailure : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 TKIPMIC Failure status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 TKIPMIC Failure status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11TkipmicFailureIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{26d8b8f6-db82-49eb-8bf3-4c130ef06950}"),
 WmiExpense(1),
 Description("NDIS Dot11 PMKID Candidate List Status Indication") : amended]
class  MSNdis_StatusDot11PmkidCandidateList : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 PMKID candidate list status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 PMKID Candidate List status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11PmkidCandidateListIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{deb45316-71b5-4736-bdef-0a9e9f4e62dc}"),
 WmiExpense(1),
 Description("NDIS Dot11 Phy State Change Status Indication") : amended]
class  MSNdis_StatusDot11PhyStateChange : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 Phy State change status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Phy State Change status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11PhyStateChangeIndication[];
};

[WMI, Dynamic, Provider("WMIProv"), guid("{a3285184-ea99-48ed-825e-a426b11c2754}"),
 WmiExpense(1),
 Description("NDIS Dot11 Link Quality Status Indication") : amended]
class  MSNdis_StatusDot11LinkQuality : WMIEvent
{
        [key, read]
        string          InstanceName;

        [read]
        boolean         Active;

    [
    read,
                Description("Number of bytes for dot11 link quality status indication") : amended,
                WmiDataId(1)]    uint32    NumberElements;
    [read,
                Description("Dot11 Link Quality status information.") : amended,
                WmiDataId(2), WmiSizeIs("NumberElements")]    uint8    NdisStatusDot11LinkQualityIndication[];
};


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

//
// AGP information
//
[abstract]
class MSAgp
{
};

[Dynamic, Provider("WMIProv"),
 WMI,
 Description("AGP Information") : amended,
 HeaderName("AGP_STD_DATA"),
 guid("{8C27FBED-1C7B-47E4-A649-0E389D3ADA4F}"),
 GuidName1("AGP_WMI_STD_DATA_GUID")
]
class MSAgp_Information : MSAgp
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [
    WmiDataId(1),
     Description("Aperture base") : amended,
     read]
    uint64 ApertureBase;

    [
    WmiDataId(2),
     Description("Aperture length") : amended,
     read]
    uint32 ApertureLength;

    [
    WmiDataId(3),
     BitValues{"AGP_RATE_1X", "AGP_RATE_2X", "AGP_RATE_4X",
           "FAST_WRITE", "FOUR_GB", "SBA_ENABLE"} : amended,
     BitMap{"0", "1", "2", "4", "5", "9"},
     Description("AGP Status") : amended,
     read]
    uint32 AgpStatus;

    [
    WmiDataId(4),
     BitValues{"AGP_RATE_1X", "AGP_RATE_2X", "AGP_RATE_4X",
           "FAST_WRITE", "FOUR_GB", "AGP_ENABLE", "SBA_ENABLE"} : amended,
     BitMap{"0", "1", "2", "4", "5", "8", "9"},
     Description("AGP Command") : amended,
     read]
    uint32 AgpCommand;
};

//
// 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 predicting 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 reporting 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 written using SPP mode") : amended,
     read]
    sint64 SppWriteCount;

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

    [DisplayName("Bounded Ecp Write Count") : amended,
    WmiDataId(6),
     Description("Bytes written 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 written 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 written 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 written 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 written 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 accurately 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
{
};

[Dynamic,
 Description("Windows Kernel Trace") : amended,
 Guid("{9e814aad-3204-11d2-9a82-006008a86939}")
]
class MSNT_SystemTrace:EventTrace
{
    [Description ("Enable Flags") : amended,
        ValueDescriptions{
            "Process creations/deletions",
            "Thread creations/deletions",
            "Image load",
            "Process counters",
            "Context switches",
            "Deferred procedure calls",
            "Interrupts",
            "System calls",
            "Disk IO",
            "File details",
            "Disk IO entry",
            "Dispatcher operations",
            "Page faults",
            "Hard page faults",
            "Virtual memory allocations",
            "Network TCP/IP",
            "Registry details",
            "ALPC",
            "Split IO",
            "Driver delays",
            "Sample based profiling",
            "File IO completion",
            "File IO"
            } : amended,
         DefineValues{
            "EVENT_TRACE_FLAG_PROCESS",
            "EVENT_TRACE_FLAG_THREAD",
            "EVENT_TRACE_FLAG_IMAGE_LOAD",
            "EVENT_TRACE_FLAG_PROCESS_COUNTERS",
            "EVENT_TRACE_FLAG_CSWITCH",
            "EVENT_TRACE_FLAG_DPC",
            "EVENT_TRACE_FLAG_INTERRUPT",
            "EVENT_TRACE_FLAG_SYSTEMCALL",
            "EVENT_TRACE_FLAG_DISK_IO",
            "EVENT_TRACE_FLAG_DISK_FILE_IO",
            "EVENT_TRACE_FLAG_DISK_IO_INIT",
            "EVENT_TRACE_FLAG_DISPATCHER",
            "EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS",
            "EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS",
            "EVENT_TRACE_FLAG_VIRTUAL_ALLOC",
            "EVENT_TRACE_FLAG_NETWORK_TCPIP",
            "EVENT_TRACE_FLAG_REGISTRY",
            "EVENT_TRACE_FLAG_ALPC",
            "EVENT_TRACE_FLAG_SPLIT_IO",
            "EVENT_TRACE_FLAG_DRIVER",
            "EVENT_TRACE_FLAG_PROFILE",
            "EVENT_TRACE_FLAG_FILE_IO",
            "EVENT_TRACE_FLAG_FILE_IO_INIT"
            },
        Values{
            "process",
            "thread",
            "img",
            "proccntr",
            "cswitch",
            "dpc",
            "isr",
            "syscall",
            "disk",
            "file",
            "diskinit",
            "dispatcher",
            "pf",
            "hf",
            "virtalloc",
            "net",
            "registry",
            "alpc",
            "splitio",
            "driver",
            "profile",
            "fileiocompletion",
            "fileio"
            },
        ValueMap{
            "0x00000001",
            "0x00000002",
            "0x00000004",
            "0x00000008",
            "0x00000010",
            "0x00000020",
            "0x00000040",
            "0x00000080",
            "0x00000100",
            "0x00000200",
            "0x00000400",
            "0x00000800",
            "0x00001000",
            "0x00002000",
            "0x00004000",
            "0x00010000",
            "0x00020000",
            "0x00100000",
            "0x00200000",
            "0x00800000",
            "0x01000000",
            "0x02000000",
            "0x04000000"

            }
    ]
    uint32 Flags;

};

[Dynamic,
 Description("Circular Kernel Session Provider") : amended,
 Guid("{54dea73a-ed1f-42a4-af71-3e63d056f174}")
]
class MSNT_CKCLTraceProvider:EventTrace
{
    [Description ("Enable Flags") : amended,
        ValueDescriptions{
            "Process creations/deletions",
            "Thread creations/deletions",
            "Image load",
            "Process counters",
            "Context switches",
            "Deferred procedure calls",
            "Interrupts",
            "System calls",
            "Disk IO",
            "File details",
            "Disk IO entry",
            "Dispatcher operations",
            "Page faults",
            "Hard page faults",
            "Virtual memory allocations",
            "Network TCP/IP",
            "Registry details",
            "ALPC",
            "Split IO",
            "Driver delays",
            "Sample based profiling",
            "File IO completion",
            "File IO"
            } : amended,
         DefineValues{
            "EVENT_TRACE_FLAG_PROCESS",
            "EVENT_TRACE_FLAG_THREAD",
            "EVENT_TRACE_FLAG_IMAGE_LOAD",
            "EVENT_TRACE_FLAG_PROCESS_COUNTERS",
            "EVENT_TRACE_FLAG_CSWITCH",
            "EVENT_TRACE_FLAG_DPC",
            "EVENT_TRACE_FLAG_INTERRUPT",
            "EVENT_TRACE_FLAG_SYSTEMCALL",
            "EVENT_TRACE_FLAG_DISK_IO",
            "EVENT_TRACE_FLAG_DISK_FILE_IO",
            "EVENT_TRACE_FLAG_DISK_IO_INIT",
            "EVENT_TRACE_FLAG_DISPATCHER",
            "EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS",
            "EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS",
            "EVENT_TRACE_FLAG_VIRTUAL_ALLOC",
            "EVENT_TRACE_FLAG_NETWORK_TCPIP",
            "EVENT_TRACE_FLAG_REGISTRY",
            "EVENT_TRACE_FLAG_ALPC",
            "EVENT_TRACE_FLAG_SPLIT_IO",
            "EVENT_TRACE_FLAG_DRIVER",
            "EVENT_TRACE_FLAG_PROFILE",
            "EVENT_TRACE_FLAG_FILE_IO",
            "EVENT_TRACE_FLAG_FILE_IO_INIT"
            },
        Values{
            "process",
            "thread",
            "img",
            "proccntr",
            "cswitch",
            "dpc",
            "isr",
            "syscall",
            "disk",
            "file",
            "diskinit",
            "dispatcher",
            "pf",
            "hf",
            "virtalloc",
            "net",
            "registry",
            "alpc",
            "splitio",
            "driver",
            "profile",
            "fileiocompletion",
            "fileio"
            },
        ValueMap{
            "0x00000001",
            "0x00000002",
            "0x00000004",
            "0x00000008",
            "0x00000010",
            "0x00000020",
            "0x00000040",
            "0x00000080",
            "0x00000100",
            "0x00000200",
            "0x00000400",
            "0x00000800",
            "0x00001000",
            "0x00002000",
            "0x00004000",
            "0x00010000",
            "0x00020000",
            "0x00100000",
            "0x00200000",
            "0x00800000",
            "0x01000000",
            "0x02000000",
            "0x04000000"

            }
    ]
    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 Circular 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,
     format("x"),
     read]
     uint32  ReservedFlags;
    [WmiDataId(21),
     Description("Number of Buffers Lost during collection") : amended,
     read]
     uint32  BuffersLost;
    [WmiDataId(22),
     Description("SessionNameString") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  SessionNameString;
    [WmiDataId(23),
     Description("LogFileNameString") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  LogFileNameString;
};

[Dynamic,
 Description("Event Trace Header Extension") : amended,
 EventType{5, 32},
 EventTypeName{"Extension", "EndExtension"} :amended
]
class Header_Extension_TypeGroup:EventTraceEvent
{
    [WmiDataId(1),
     Description("GroupMask1") : amended,
     format("x"),
     read]
     uint32  GroupMask1;
    [WmiDataId(2),
     Description("GroupMask2") : amended,
     format("x"),
     read]
     uint32  GroupMask2;
    [WmiDataId(3),
     Description("GroupMask3") : amended,
     format("x"),
     read]
     uint32  GroupMask3;
    [WmiDataId(4),
     Description("GroupMask4") : amended,
     format("x"),
     read]
     uint32  GroupMask4;
    [WmiDataId(5),
     Description("GroupMask5") : amended,
     format("x"),
     read]
     uint32  GroupMask5;
    [WmiDataId(6),
     Description("GroupMask6") : amended,
     format("x"),
     read]
     uint32  GroupMask6;
    [WmiDataId(7),
     Description("GroupMask7") : amended,
     format("x"),
     read]
     uint32  GroupMask7;
    [WmiDataId(8),
     Description("GroupMask8") : amended,
     format("x"),
     read]
     uint32  GroupMask8;
    [WmiDataId(9),
     Description("KernelEventVersion") : amended,
     format("x"),
     read]
     uint32  KernelEventVersion;
};

[Dynamic,
 Description("Event Trace Rundown Complete") : amended,
 EventType(8),
 EventTypeName("RDComplete") :amended
]
class RDComplete:EventTraceEvent
{

};

[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_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Process_V1_TypeGroup1:Process_V1
{
    [WmiDataId(1),
     Description("PageDirectoryBase") : amended,
     pointer,
     read]
     uint32  PageDirectoryBase;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(3),
     Description("ParentId") : amended,
     format("x"),
     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("Process Create/Exit Event") : amended,
 Guid("{3d6fa8d0-fe05-11d0-9dda-00c04fd7ba7c}"),
 EventVersion(2),
 DisplayName("Process") : amended
]
class Process_V2:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Process Create/Exit Event") : amended,
 EventType{1, 2, 3, 4, 39},
 EventTypeName{"Start", "End", "DCStart", "DCEnd", "Defunct"} : amended
]
class Process_V2_TypeGroup1:Process_V2
{
    [WmiDataId(1),
     Description("UniqueProcessKey") : amended,
     pointer,
     read]
     uint32  UniqueProcessKey;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(3),
     Description("ParentId") : amended,
     format("x"),
     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;
    [WmiDataId(8),
     Description("CommandLine") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  CommandLine;
};

[Dynamic,
 Description("Process Performance Counters") : amended,
 EventType{32, 33},
 EventTypeName{"PerfCtr", "PerfCtrRundown"} : amended
]
class Process_V2_TypeGroup2:Process_V2
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("PageFaultCount") : amended,
     read]
     uint32  PageFaultCount;
    [WmiDataId(3),
     Description("HandleCount") : amended,
     read]
     uint32  HandleCount;
    [WmiDataId(4),
     Description("Reserved") : amended,
     read]
     uint32  Reserved;
    [WmiDataId(5),
     Description("PeakVirtualSize") : amended,
     extension("SizeT"),
     read]
     object  PeakVirtualSize;
    [WmiDataId(6),
     Description("PeakWorkingSetSize") : amended,
     extension("SizeT"),
     read]
     object  PeakWorkingSetSize;
    [WmiDataId(7),
     Description("PeakPagefileUsage") : amended,
     extension("SizeT"),
     read]
     object  PeakPagefileUsage;
    [WmiDataId(8),
     Description("QuotaPeakPagedPoolUsage") : amended,
     extension("SizeT"),
     read]
     object  QuotaPeakPagedPoolUsage;
    [WmiDataId(9),
     Description("QuotaPeakNonPagedPoolUsage") : amended,
     extension("SizeT"),
     read]
     object  QuotaPeakNonPagedPoolUsage;
    [WmiDataId(10),
     Description("VirtualSize") : amended,
     extension("SizeT"),
     read]
     object  VirtualSize;
    [WmiDataId(11),
     Description("WorkingSetSize") : amended,
     extension("SizeT"),
     read]
     object  WorkingSetSize;
    [WmiDataId(12),
     Description("PagefileUsage") : amended,
     extension("SizeT"),
     read]
     object  PagefileUsage;
    [WmiDataId(13),
     Description("QuotaPagedPoolUsage") : amended,
     extension("SizeT"),
     read]
     object  QuotaPagedPoolUsage;
    [WmiDataId(14),
     Description("QuotaNonPagedPoolUsage") : amended,
     extension("SizeT"),
     read]
     object  QuotaNonPagedPoolUsage;
    [WmiDataId(15),
     Description("PrivatePageCount") : amended,
     extension("SizeT"),
     read]
     object  PrivatePageCount;
};

[Dynamic,
 Description("Process In Swap Event") : amended,
 EventType(35),
 EventTypeName("InSwap") : amended
]
class Process_V2_TypeGroup3:Process_V2
{
    [WmiDataId(1),
     Description("DirectoryTableBase") : amended,
     pointer,
     read]
     uint32  DirectoryTableBase;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
};

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

};

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

[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_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{1, 3},
 EventTypeName{"Start", "DCStart"} : amended
]
class Thread_V1_TypeGroup1:Thread_V1
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     format("x"),
     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,
     read]
     sint8  WaitMode;
};

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


[Dynamic,
 Description("Context Switch Event") : amended,
 EventType(36),
 EventTypeName("CSwitch") : amended
]
class CSwitch_V1:Thread_V1
{
    [WmiDataId(1),
     Description("NewThreadId") : amended,
     format("x"),
     read]
     uint32  NewThreadId;
    [WmiDataId(2),
     Description("OldThreadId") : amended,
     format("x"),
     read]
     uint32  OldThreadId;
    [WmiDataId(3),
     Description("NewThreadPriority") : amended,
     read]
     sint8  NewThreadPriority;
    [WmiDataId(4),
     Description("OldThreadPriority") : amended,
     read]
     sint8  OldThreadPriority;
    [WmiDataId(5),
     Description("NewThreadQuantum") : amended,
     read]
     sint8  NewThreadQuantum;
    [WmiDataId(6),
     Description("OldThreadQuantum") : amended,
     read]
     sint8  OldThreadQuantum;
    [WmiDataId(7),
     Description("OldThreadWaitReason") : amended,
     read]
     sint8  OldThreadWaitReason;
    [WmiDataId(8),
     Description("OldThreadWaitMode") : amended,
     read]
     sint8  OldThreadWaitMode;
    [WmiDataId(9),
     Description("OldThreadState") : amended,
     read]
     sint8  OldThreadState;
    [WmiDataId(10),
     Description("OldThreadWaitIdealProcessor") : amended,
     read]
     sint8  OldThreadWaitIdealProcessor;
    [WmiDataId(11),
     Description("NewThreadWaitTime") : amended,
     format("x"),
     read]
     uint32  NewThreadWaitTime;
};

[Dynamic,
 Description("Worker Thread Event") : amended,
 EventType(57),
 EventTypeName("WorkerThread") : amended
]
class WorkerThread_V1:Thread_V1
{
    [WmiDataId(1),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  TThreadId;
    [WmiDataId(2),
     Description("StartTime") : amended,
     read]
     uint64  StartTime;
    [WmiDataId(3),
     Description("ThreadRoutine") : amended,
     pointer,
     read]
     uint32  ThreadRoutine;
};

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

};

[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Thread_V2_TypeGroup1:Thread_V2
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     format("x"),
     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("TebBase") : amended,
     pointer,
     read]
     uint32  TebBase;
    [WmiDataId(10),
     Description("SubProcessTag") : amended,
     format("x"),
     read]
     uint32  SubProcessTag;
};

[Dynamic,
 Description("Context Switch Event") : amended,
 EventType(36),
 EventTypeName("CSwitch") : amended
]
class CSwitch:Thread_V2
{
    [WmiDataId(1),
     Description("NewThreadId") : amended,
     format("x"),
     read]
     uint32  NewThreadId;
    [WmiDataId(2),
     Description("OldThreadId") : amended,
     format("x"),
     read]
     uint32  OldThreadId;
    [WmiDataId(3),
     Description("NewThreadPriority") : amended,
     read]
     sint8  NewThreadPriority;
    [WmiDataId(4),
     Description("OldThreadPriority") : amended,
     read]
     sint8  OldThreadPriority;
    [WmiDataId(5),
     Description("PreviousCState") : amended,
     read]
     uint8  PreviousCState;
    [WmiDataId(6),
     Description("SpareByte") : amended,
     read]
     sint8  SpareByte;
    [WmiDataId(7),
     Description("OldThreadWaitReason") : amended,
     read]
     sint8  OldThreadWaitReason;
    [WmiDataId(8),
     Description("OldThreadWaitMode") : amended,
     read]
     sint8  OldThreadWaitMode;
    [WmiDataId(9),
     Description("OldThreadState") : amended,
     read]
     sint8  OldThreadState;
    [WmiDataId(10),
     Description("OldThreadWaitIdealProcessor") : amended,
     read]
     sint8  OldThreadWaitIdealProcessor;
    [WmiDataId(11),
     Description("NewThreadWaitTime") : amended,
     format("x"),
     read]
     uint32  NewThreadWaitTime;
    [WmiDataId(12),
     Description("Reserved") : amended,
     read]
     uint32  Reserved;
};

[Dynamic,
 Description("Compressed CS Event") : amended,
 EventType(37),
 EventTypeName("CompCS") : amended
]
class CompCS:Thread_V2
{
};

[Dynamic,
 Description("Worker Thread Event") : amended,
 EventType(57),
 EventTypeName("WorkerThread") : amended
]
class WorkerThread:Thread_V2
{
    [WmiDataId(1),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  TThreadId;
    [WmiDataId(2),
     Description("StartTime") : amended,
     read]
     uint64  StartTime;
    [WmiDataId(3),
     Description("ThreadRoutine") : amended,
     pointer,
     read]
     uint32  ThreadRoutine;
};

[Dynamic,
 Description("Ready Thread Event") : amended,
 EventType(50),
 EventTypeName("ReadyThread") : amended
]
class ReadyThread:Thread_V2
{
    [WmiDataId(1),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  TThreadId;
   [WmiDataId(2),
     Description("AdjustReason") : amended,
     read]
     sint8  AdjustReason;
   [WmiDataId(3),
     Description("AdjustIncrement") : amended,
     read]
     sint8  AdjustIncrement;
   [WmiDataId(4),
     Description("Flags") : amended,
     read]
     sint8  Flag;
   [WmiDataId(5),
     Description("Reserved") : amended,
     read]
     sint8  Reserved;
};


[Dynamic,
 Description("Thread Affinity Event") : amended,
 EventType(53),
 EventTypeName("ThreadAffinity") : amended
]
class ThreadAffinity:Thread_V2
{
    [WmiDataId(1),
     Description("Affinity") : amended,
     pointer,
     read] 
     uint32   Affinity;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  ThreadId;
   [WmiDataId(3),
     Description("Group") : amended,
     read]
     uint16  Group;
   [WmiDataId(4),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
};

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

};
 
[Dynamic,
 Description("Thread Create/Exit Event") : amended,
 EventType{1, 2, 3, 4},
 EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
]
class Thread_TypeGroup1:Thread
{
   [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     format("x"),
     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("Affinity") : amended,
     pointer,
     read]
     uint32  Affinity;
    [WmiDataId(8),
     Description("Win32StartAddr") : amended,
     pointer,
     read]
     uint32  Win32StartAddr;
    [WmiDataId(9),
     Description("TebBase") : amended,
     pointer,
     read]
     uint32  TebBase;
    [WmiDataId(10),
     Description("SubProcessTag") : amended,
     format("x"),
     read]
     uint32  SubProcessTag;
    [WmiDataId(11),
     Description("BasePriority") : amended,
     read] 
     uint8   BasePriority;
    [WmiDataId(12),
     Description("PagePriority") : amended,
     read] 
     uint8   PagePriority;
    [WmiDataId(13),
     Description("IoPriority") : amended,
     read] 
     uint8   IoPriority;
    [WmiDataId(14),
     Description("Flags") : amended,
     read] 
     uint8   ThreadFlags;
};

[Dynamic,
 Description("Priority Change Event") : amended,
 EventType{48, 49, 51, 52},
 EventTypeName{"SetPriority", "SetBasePriority", "SetPagePriority", "SetIoPriority"} : amended
]
class ThreadPriority:Thread
{
    [WmiDataId(1),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  ThreadId;
    [WmiDataId(2),
     Description("OldPriority") : amended,
     read] 
     uint8   OldPriority;
   [WmiDataId(3),
     Description("NewPriority") : amended,
     read] 
     uint8   NewPriority;
   [WmiDataId(4),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
};

[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("Reserved") : amended,
     read]
     uint32  Reserved;
    [WmiDataId(5),
     Description("ByteOffset") : amended,
     read]
     uint64  ByteOffset;
    [WmiDataId(6),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(7),
     Description("IORequestPacket") : amended,
     pointer,
     read]
     uint32  Irp;
    [WmiDataId(8),
     Description("HighResResponseTime") : amended,
     read]
     uint64  HighResResponseTime;
};

[Dynamic,
 Description("I/O Read/Write/Flush Start Event") : amended,
 EventType{12, 13, 15},
 EventTypeName{"ReadInit", "WriteInit", "FlushInit"} : amended
]
class DiskIo_TypeGroup2:DiskIo
{
    [WmiDataId(1),
     Description("IORequestPacket") : amended,
     pointer,
     read]
     uint32  Irp;
};

[Dynamic,
 Description("I/O Flush Buffers Event") : amended,
 EventType(14),
 EventTypeName("FlushBuffers") : amended
]
class DiskIo_TypeGroup3:DiskIo
{
    [WmiDataId(1),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(2),
     Description("IrpFlags") : amended,
     format("x"),
     read]
     uint32  IrpFlags;
    [WmiDataId(3),
     Description("HighResResponseTime") : amended,
     read]
     uint64  HighResResponseTime;
    [WmiDataId(4),
     Description("IORequestPacket") : amended,
     pointer,
     read]
     uint32  Irp;
};

[Dynamic,
 Description("Driver Major Function Call") : amended,
 EventType(34),
 EventTypeName("DrvMjFnCall") : amended
]
class DriverMajorFunctionCall:DiskIo
{
    [WmiDataId(1),
     Description("MajorFunction") : amended,
     read]
     uint32  MajorFunction;
    [WmiDataId(2),
     Description("MinorFunction") : amended,
     read]
     uint32  MinorFunction;
    [WmiDataId(3),
     Description("RoutineAddr") : amended,
     pointer,
     read]
     uint32  RoutineAddr;
    [WmiDataId(4),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(5),
     Description("Irp") : amended,
     pointer,
     read]
     uint32  Irp;
    [WmiDataId(6),
     Description("UniqMatchId") : amended,
     read]
     uint32  UniqMatchId;
};

[Dynamic,
 Description("Driver Major Function Return") : amended,
 EventType(35),
 EventTypeName("DrvMjFnRet") : amended
]
class DriverMajorFunctionReturn:DiskIo
{
    [WmiDataId(1),
     Description("Irp") : amended,
     pointer,
     read]
     uint32  Irp;
    [WmiDataId(2),
     Description("UniqMatchId") : amended,
     read]
     uint32  UniqMatchId;
};

[Dynamic,
 Description("Driver Completion Routine") : amended,
 EventType(37),
 EventTypeName("DrvComplRout") : amended
]
class DriverCompletionRoutine:DiskIo
{
    [WmiDataId(1),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
    [WmiDataId(2),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(3),
     Description("UniqMatchId") : amended,
     read]
     uint32  UniqMatchId;
};

[Dynamic,
 Description("Driver Complete Request") : amended,
 EventType(52),
 EventTypeName("DrvComplReq") : amended
]
class DriverCompleteRequest:DiskIo
{
    [WmiDataId(1),
     Description("RoutineAddr") : amended,
     pointer,
     read]
     uint32  RoutineAddr;
    [WmiDataId(2),
     Description("Irp") : amended,
     pointer,
     read]
     uint32  Irp;
    [WmiDataId(3),
     Description("UniqMatchId") : amended,
     read]
     uint32  UniqMatchId;
};

[Dynamic,
 Description("Driver Delay Complete Request Return") : amended,
 EventType(53),
 EventTypeName("DrvComplReqRet") : amended
]
class DriverCompleteRequestReturn:DiskIo
{
    [WmiDataId(1),
     Description("Irp") : amended,
     pointer,
     read]
     uint32  Irp;
    [WmiDataId(2),
     Description("UniqMatchId") : amended,
     read]
     uint32  UniqMatchId;
};

[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_V1: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_V1_TypeGroup1:Registry_V1
{
    [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("Registry") : amended,
 Guid("{ae53722e-c863-11d2-8659-00c04fa321a1}"),
 EventVersion(2),
 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, 23, 24, 25, 26, 27, 28, 29},
 EventTypeName{"Create", "Open", "Delete", "Query", "SetValue", "DeleteValue", "QueryValue", "EnumerateKey", "EnumerateValueKey", "QueryMultipleValue", "SetInformation", "Flush", "KCBCreate", "KCBDelete", "KCBRundownBegin", "KCBRundownEnd", "Virtualize", "Close", "SetSecurity", "QuerySecurity"} : amended
]
class Registry_TypeGroup1:Registry
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     read]
     sint64  InitialTime;

    [WmiDataId(2),
     Description("Status") : amended,
     read]
     uint32  Status;

    [WmiDataId(3),
     Description("Index") : amended,
     read]
     uint32  Index;

    [WmiDataId(4),
     Description("KeyHandle") : amended,
     pointer,
     read]
     uint32  KeyHandle;

    [WmiDataId(5),
     Description("KeyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  KeyName;
};

[Dynamic,
 Description("Registry") : amended,
 EventType{30, 31,32},
 EventTypeName{"TxRCommit", "TxRPrepare", "TxRRollback"} : amended
]
class Registry_TxR:Registry
{

    [WmiDataId(1),
     Description("TxRGUID") : amended,
     extension("GUID"),
     read]
     uint8  TxrGUID[16];


    [WmiDataId(2),
     Description("Status") : amended,
     read]
     uint32  Status;

    [WmiDataId(3),
     Description("UOW Count") : amended,
     read]
     uint32  UowCount;

    [WmiDataId(4),
     Description("Operation Time") : amended,
     read]
     uint64  OperationTime;

    [WmiDataId(5),
     Description("Hive") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  Hive;

};

[Dynamic,
 Description("Registry") : amended,
 EventType(34),
 EventTypeName("Counters") : amended
]
class Registry_Counters:Registry
{
    [WmiDataId(1),
     Description("Counter") : amended,
     read]
     uint64  Counter1;
    [WmiDataId(2),
     Description("Counter") : amended,
     read]
     uint64  Counter2;
    [WmiDataId(3),
     Description("Counter") : amended,
     read]
     uint64  Counter3;
    [WmiDataId(4),
     Description("Counter") : amended,
     read]
     uint64  Counter4;
    [WmiDataId(5),
     Description("Counter") : amended,
     read]
     uint64  Counter5;
    [WmiDataId(6),
     Description("Counter") : amended,
     read]
     uint64  Counter6;
    [WmiDataId(7),
     Description("Counter") : amended,
     read]
     uint64  Counter7;
    [WmiDataId(8),
     Description("Counter") : amended,
     read]
     uint64  Counter8;
    [WmiDataId(9),
     Description("Counter") : amended,
     read]
     uint64  Counter9;
    [WmiDataId(10),
     Description("Counter") : amended,
     read]
     uint64  Counter10;
    [WmiDataId(11),
     Description("Counter") : amended,
     read]
     uint64  Counter11;
};


[Dynamic,
 Description("Registry") : amended,
 EventType(35),
 EventTypeName("Config") : amended
]
class Registry_Config:Registry
{
    [WmiDataId(1),
     Description("Current Control Set") : amended,
     read]
     uint32  CurrentControlSet;
};


[Dynamic,
 Description("Split IO Event") : amended,
 Guid("{d837ca92-12b9-44a5-ad6a-3a65b3578aa8}"),
 DisplayName("SplitIo") : amended,
 locale("MS\\0x409")
]
class SplitIo:MSNT_SystemTrace
{
};

[Dynamic,
 Description("Split IO") : amended,
 EventType(32),
 EventTypeName("VolMgr") : amended,
 locale("MS\\0x409")
]
class SplitIo_Info:SplitIo
{
    [WmiDataId(1),
     Description("ParentIrp") : amended,
     pointer,
     read]
     uint32  ParentIrp;
    [WmiDataId(2),
     Description("ChildIrp") : amended,
     pointer,
     read]
     uint32  ChildIrp;
};

[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_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("File Name") : amended,
 EventType{0, 32},
 EventTypeName{"Name", "FileCreate"} : amended
]
class FileIo_V1_Name:FileIo_V1
{
    [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(2),
 DisplayName("FileIo") : amended
]
class FileIo:MSNT_SystemTrace
{

};

[Dynamic,
 Description("File Name") : amended,
 EventType{0, 32, 35, 36},
 EventTypeName{"Name", "FileCreate", "FileDelete", "FileRundown"} : 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("File Create") : amended,
 EventType(64),
 EventTypeName("Create") : amended
]
class FileIo_Create:FileIo
{
    [WmiDataId(1),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(2),
     Description("TTID") : amended,
     pointer,
     read]
     uint32  TTID;
    [WmiDataId(3),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(4),
     Description("CreateOptions") : amended,
     read]
     uint32  CreateOptions;
    [WmiDataId(5),
     Description("FileAttributes") : amended,
     read]
     uint32  FileAttributes;
    [WmiDataId(6),
     Description("ShareAccess") : amended,
     read]
     uint32  ShareAccess;
    [WmiDataId(7),
     Description("OpenPath") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  OpenPath;
};

[Dynamic,
 Description("File Simple Operation") : amended,
 EventType{65, 66, 73},
 EventTypeName{"Cleanup", "Close", "Flush"} : amended
]
class FileIo_SimpleOp:FileIo
{
    [WmiDataId(1),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(2),
     Description("TTID") : amended,
     pointer,
     read]
     uint32  TTID;
    [WmiDataId(3),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(4),
     Description("FileKey") : amended,
     pointer,
     read]
     uint32  FileKey;
};

[Dynamic,
 Description("File Read Write") : amended,
 EventType{67, 68},
 EventTypeName{"Read", "Write"} : amended
]
class FileIo_ReadWrite:FileIo
{
    [WmiDataId(1),
     Description("Offset") : amended,
     read]
     uint64  Offset;
    [WmiDataId(2),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(3),
     Description("TTID") : amended,
     pointer,
     read]
     uint32  TTID;
    [WmiDataId(4),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(5),
     Description("FileKey") : amended,
     pointer,
     read]
     uint32  FileKey;
    [WmiDataId(6),
     Description("IoSize") : amended,
     read]
     uint32  IoSize;
    [WmiDataId(7),
     Description("IoFlags") : amended,
     read]
     uint32  IoFlags;
};


[Dynamic,
 Description("File Information") : amended,
 EventType{69, 70, 71, 74, 75},
 EventTypeName{"SetInfo", "Delete", "Rename", "QueryInfo", "FSControl"} : amended
]
class FileIo_Info:FileIo
{
    [WmiDataId(1),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(2),
     Description("TTID") : amended,
     pointer,
     read]
     uint32  TTID;
    [WmiDataId(3),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(4),
     Description("FileKey") : amended,
     pointer,
     read]
     uint32  FileKey;
    [WmiDataId(5),
     Description("ExtraInfo") : amended,
     pointer,
     read]
     uint32  ExtraInfo;
    [WmiDataId(6),
     Description("InfoClass") : amended,
     read]
     uint32  InfoClass;
};

[Dynamic,
 Description("File Dir Enum") : amended,
 EventType{72, 77},
 EventTypeName{"DirEnum", "DirNotify"} : amended
]
class FileIo_DirEnum:FileIo
{
    [WmiDataId(1),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(2),
     Description("TTID") : amended,
     pointer,
     read]
     uint32  TTID;
    [WmiDataId(3),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(4),
     Description("FileKey") : amended,
     pointer,
     read]
     uint32  FileKey;
    [WmiDataId(5),
     Description("Length") : amended,
     read]
     uint32  Length;
    [WmiDataId(6),
     Description("InfoClass") : amended,
     read]
     uint32  InfoClass;
    [WmiDataId(7),
     Description("FileIndex") : amended,
     read]
     uint32  FileIndex;
    [WmiDataId(8),
     Description("FileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  FileName;
};


[Dynamic,
 Description("File Operation End") : amended,
 EventType(76),
 EventTypeName("OperationEnd") : amended
]
class FileIo_OpEnd:FileIo
{
    [WmiDataId(1),
     Description("IrpPtr") : amended,
     pointer,
     read]
     uint32  IrpPtr;
    [WmiDataId(2),
     Description("ExtraInfo") : amended,
     pointer,
     read]
     uint32  ExtraInfo;
    [WmiDataId(3),
     Description("NtStatus") : amended,
     read]
     uint32  NtStatus;
};

[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}"),
 EventVersion(1),
 DisplayName("TcpIp") : amended
]
class TcpIp_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("TcpIp Receive") : amended,
  EventType(11),
  EventTypeName("Recv") : amended
]
class TcpIp_V1_Receive:TcpIp_V1
{
    [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;
    [WmiDataId(7),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
    [WmiDataId(8),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
};

[Dynamic,
 Description("TcpIp Disconnect") : amended,
  EventType{13, 14, 16},
  EventTypeName{"Disconnect", "Retransmit", "Reconnect"} : amended
]
class TcpIp_V1_TypeGroup1:TcpIp_V1
{
    [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;
    [WmiDataId(7),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
    [WmiDataId(8),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
};

[Dynamic,
 Description("TcpIp Connect/Accept") : amended,
 EventType{12, 15},
 EventTypeName{"Connect", "Accept"} : amended
]
class TcpIp_V1_TypeGroup2:TcpIp_V1
{
    [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;
    [WmiDataId(7),
    Description("MSS") : amended,
    read]
    uint16 mss;
    [WmiDataId(8),
    Description("SACK Option") : amended,
    read]
    uint16 sackopt;
    [WmiDataId(9),
    Description("TimeStamp Option") : amended,
    read]
    uint16 tsopt;
    [WmiDataId(10),
    Description("WindowScale Option") : amended,
    read]
    uint16 wsopt;
    [WmiDataId(11),
    Description("TCP Window Size") : amended,
    read]
    uint32 rcvwin;
    [WmiDataId(12),
    Description("Receive Window Scale") : amended,
    read]
    sint16 rcvwinscale;
    [WmiDataId(13),
    Description("Send Window Scale") : amended,
    read]
    sint16 sndwinscale;
    [WmiDataId(14),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
    [WmiDataId(15),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
};

[Dynamic,
 Description("TcpIp Fail") : amended,
 EventType(17),
 EventTypeName("Fail") : amended
]
class TcpIp_V1_Fail:TcpIp_V1
{
    [WmiDataId(1),
     Description("Protocol") : amended,
     read]
     uint32  Proto;
};

[Dynamic,
 Description("TcpIp Send") : amended,
 EventType(10),
 EventTypeName("Send") : amended
]
class TcpIp_V1_Send:TcpIp_V1
{
    [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;
    [WmiDataId(7),
     Description("Start SendReq Time") : amended,
     read]
     uint32 startime;
    [WmiDataId(8),
     Description("End SendReq Time") : amended,
     read]
     uint32 endtime;
    [WmiDataId(9),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
    [WmiDataId(10),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
};

[Dynamic,
 Description("TcpIp Copy/ACK") : amended,
 EventType{18, 19, 20, 21, 22},
 EventTypeName{"TCPCopy", "ARPCopy", "FullACK", "PartACK", "DupACK"} : amended
]
class TcpIp_V1_TypeGroup3:TcpIp_V1
{
    [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;
    [WmiDataId(7),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
    [WmiDataId(8),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
};

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

};

[Dynamic,
 Description("TcpIp IPV4 Send") : amended,
 EventType(10),
 EventTypeName("SendIPV4") : amended
]
class TcpIp_SendIPV4: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("IPAddrV4"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV4"),
     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;
    [WmiDataId(7),
     Description("Start SendReq Time") : amended,
     read]
     uint32 startime;
    [WmiDataId(8),
     Description("End SendReq Time") : amended,
     read]
     uint32 endtime;
    [WmiDataId(9),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(10),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("TcpIp IPV4 Generic") : amended,
  EventType{11, 13, 14, 16, 18},
  EventTypeName{"RecvIPV4", "DisconnectIPV4", "RetransmitIPV4", "ReconnectIPV4", "TCPCopyIPV4"} : 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("IPAddrV4"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV4"),
     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;
    [WmiDataId(7),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(8),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("TcpIp IPV4 Connect/Accept") : amended,
 EventType{12, 15},
 EventTypeName{"ConnectIPV4", "AcceptIPV4"} : amended
]
class TcpIp_TypeGroup2: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("IPAddrV4"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV4"),
     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;
    [WmiDataId(7),
     Description("MSS") : amended,
     read]
     uint16 mss;
    [WmiDataId(8),
     Description("SACK Option") : amended,
     read]
     uint16 sackopt;
    [WmiDataId(9),
     Description("TimeStamp Option") : amended,
     read]
     uint16 tsopt;
    [WmiDataId(10),
     Description("WindowScale Option") : amended,
     read]
     uint16 wsopt;
    [WmiDataId(11),
     Description("TCP Window Size") : amended,
     read]
     uint32 rcvwin;
    [WmiDataId(12),
     Description("Receive Window Scale") : amended,
     read]
     sint16 rcvwinscale;
    [WmiDataId(13),
     Description("Send Window Scale") : amended,
     read]
     sint16 sndwinscale;
    [WmiDataId(14),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(15),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("TcpIp Fail") : amended,
 EventType(17),
 EventTypeName("Fail") : amended
]
class TcpIp_Fail:TcpIp
{
    [WmiDataId(1),
     Description("Protocol") : amended,
     read]
     uint16  Proto;
    [WmiDataId(2),
     Description("FailureCode") : amended,
     read]
     uint16  FailureCode;
};

[Dynamic,
 Description("TcpIp IPV6 Send") : amended,
 EventType(26),
 EventTypeName("SendIPV6") : amended
]
class TcpIp_SendIPV6: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("IPAddrV6"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV6"),
     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;
    [WmiDataId(7),
     Description("Start SendReq Time") : amended,
     read]
     uint32 startime;
    [WmiDataId(8),
     Description("End SendReq Time") : amended,
     read]
     uint32 endtime;
    [WmiDataId(9),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(10),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("TcpIp IPV6 Generic") : amended,
  EventType{27, 29, 30, 32, 34},
  EventTypeName{"RecvIPV6", "DisconnectIPV6", "RetransmitIPV6", "ReconnectIPV6", "TCPCopyIPV6"} : amended
]
class TcpIp_TypeGroup3: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("IPAddrV6"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV6"),
     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;
    [WmiDataId(7),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(8),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("TcpIp IPV6 Connect/Accept") : amended,
 EventType{28, 31},
 EventTypeName{"ConnectIPV6", "AcceptIPV6"} : amended
]
class TcpIp_TypeGroup4: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("IPAddrV6"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV6"),
     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;
    [WmiDataId(7),
     Description("MSS") : amended,
     read]
     uint16 mss;
    [WmiDataId(8),
     Description("SACK Option") : amended,
     read]
     uint16 sackopt;
    [WmiDataId(9),
     Description("TimeStamp Option") : amended,
     read]
     uint16 tsopt;
    [WmiDataId(10),
     Description("WindowScale Option") : amended,
     read]
     uint16 wsopt;   
    [WmiDataId(11),
     Description("TCP Window Size") : amended,
     read]
     uint32 rcvwin;
    [WmiDataId(12),
     Description("Receive Window Scale") : amended,
     read]
     sint16 rcvwinscale;
    [WmiDataId(13),
     Description("Send Window Scale") : amended,
     read]
     sint16 sndwinscale;
    [WmiDataId(14),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(15),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

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

};

[Dynamic,
 Description("UdpIp 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}"),
 EventVersion(1),
 DisplayName("UdpIp") : amended
]
class UdpIp_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("UdpIp Send/Receive") : amended,
 EventType{10, 11},
 EventTypeName{"Send", "Recv"} : amended
]
class UdpIp_V1_TypeGroup1:UdpIp_V1
{
    [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("UdpIp Send/Receive") : amended,
 Guid("{bf3a50c5-a9c9-4988-a005-2df0b7c80f80}"),
 EventVersion(2),
 DisplayName("UdpIp") : amended
]
class UdpIp:MSNT_SystemTrace
{

};

[Dynamic,
 Description("UdpIp IPV4 Send/Receive") : amended,
 EventType{10, 11},
 EventTypeName{"SendIPV4", "RecvIPV4"} : 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("IPAddrV4"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV4"),
     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;
    [WmiDataId(7),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(8),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[Dynamic,
 Description("UdpIp Fail") : amended,
 EventType(17),
 EventTypeName("Fail") : amended
]
class UdpIp_Fail:UdpIp
{
    [WmiDataId(1),
     Description("Protocol") : amended,
     read]
     uint16  Proto;
    [WmiDataId(2),
     Description("FailureCode") : amended,
     read]
     uint16  FailureCode;
};

[Dynamic,
 Description("UdpIp IPV6 Send/Receive") : amended,
 EventType{26, 27},
 EventTypeName{"SendIPV6", "RecvIPV6"} : amended
]
class UdpIp_TypeGroup2: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("IPAddrV6"),
     read]
     object  daddr;
    [WmiDataId(4),
     Description("Local IP Address") : amended,
     extension("IPAddrV6"),
     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;
    [WmiDataId(7),
     Description("Sequence Number") : amended,
     read]
     uint32 seqnum;
    [WmiDataId(8),
     Description("ConnID") : amended,
     PointerType,
     read]
     uint32 connid;
};

[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_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Image Load") : amended,
 EventType(10),
 EventTypeName("Load") : amended
]
class Image_V1_Load:Image_V1
{
    [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("Image Load") : amended,
 Guid("{2cb15d1d-5fc1-11d2-abe1-00a0c911f518}"),
 EventVersion(2),
 DisplayName("Image") : amended
]
class Image:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Image Load") : amended,
 EventType{10, 2, 3, 4},
 EventTypeName{"Load", "UnLoad", "DCStart", "DCEnd"} : 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("ImageChecksum") : amended,
     read]
     uint32  ImageChecksum;
    [WmiDataId(5),
     Description("TimeDateStamp") : amended,
     read]
     uint32  TimeDateStamp;
    [WmiDataId(6),
     Description("Reserved0") : amended,
     read]
     uint32  Reserved0;
    [WmiDataId(7),
     Description("DefaultBase") : amended,
     pointer,
     read]
     uint32  DefaultBase;
    [WmiDataId(8),
     Description("Reserved1") : amended,
     read]
     uint32  Reserved1;
    [WmiDataId(9),
     Description("Reserved2") : amended,
     read]
     uint32  Reserved2;
    [WmiDataId(10),
     Description("Reserved3") : amended,
     read]
     uint32  Reserved3;
    [WmiDataId(11),
     Description("Reserved4") : amended,
     read]
     uint32  Reserved4;
    [WmiDataId(12),
     Description("FileName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  FileName;

};

[Dynamic,
 Description("Kernel Image Base") : amended,
 EventType(33),
 EventTypeName("KernelBase") : amended
]
class KernelImageBase:Image
{
    [WmiDataId(1),
     Description("ImageBase") : amended,
     pointer,
     read]
     uint32  ImageBase;
};

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

};

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

[Dynamic,
 Description("Hard Page Fault Event") : amended,
 EventType(32),
 EventTypeName("HardFault") : amended
]
class PageFault_HardFault:PageFault_V2
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("ReadOffset") : amended,
     format("x"),
     read]
     uint64  ReadOffset;
    [WmiDataId(3),
     Description("VirtualAddress") : amended,
     pointer,
     read]
     uint32  VirtualAddress;
    [WmiDataId(4),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(5),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  TThreadId;
    [WmiDataId(6),
     Description("ByteCount") : amended,
     read]
     uint32  ByteCount;
};

[Dynamic,
 Description("Heap Range Rundown Event") : amended,
 EventType(100),
 EventTypeName("HRRundown") : amended
]
class PageFault_HeapRangeRundown_V2:PageFault_V2
{
    [WmiDataId(1),
     Description("HeapHandle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("HRFlags") : amended,
     format("x"),
     read]
     uint32  HRFlags;
    [WmiDataId(3),
     Description("HRPid") : amended,
     format("x"),
     read]
     uint32  HRPid;
    [WmiDataId(4),
     Description("HRRangeCount") : amended,
     read]
     uint32  HRRangeCount;
};

[Dynamic,
 Description("Heap Range Create Event") : amended,
 EventType(101),
 EventTypeName("HRCreate") : amended
]
class PageFault_HeapRangeCreate:PageFault_V2
{
    [WmiDataId(1),
     Description("HeapHandle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("FirstRangeSize") : amended,
     extension("SizeT"),
     read]
     object  FirstRangeSize;
    [WmiDataId(3),
     Description("HRCreateFlags") : amended,
     format("x"),
     read]
     uint32  HRCreateFlags;
};

[Dynamic,
 Description("Heap Range Event") : amended,
 EventType{102, 103},
 EventTypeName{"HRReserve", "HRRelease"} : amended
]
class PageFault_HeapRangeTypeGroup:PageFault_V2
{
    [WmiDataId(1),
     Description("HeapHandle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("HRAddress") : amended,
     pointer,
     read]
     uint32  HRAddress;
    [WmiDataId(3),
     Description("HRSize") : amended,
     extension("SizeT"),
     read]
     object  HRSize;
};

[Dynamic,
 Description("Heap Range Destroy Event") : amended,
 EventType(104),
 EventTypeName("HRDestroy") : amended
]
class PageFault_HeapRangeDestroy:PageFault_V2
{
    [WmiDataId(1),
     Description("HeapHandle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
};

[Dynamic,
 Description("Image Load in PageFile Event") : amended,
 EventType(105),
 EventTypeName("ImageLoadBacked") : amended
]
class PageFault_ImageLoadBacked:PageFault_V2
{
    [WmiDataId(1),
     Description("FileObject") : amended,
     pointer,
     read]
     uint32  FileObject;
    [WmiDataId(2),
     Description("DeviceChar") : amended,
     format("x"),
     read]
     uint32  DeviceChar;
    [WmiDataId(3),
     Description("FileChar") : amended,
     format("x"),
     read]
     uint16  FileChar;
    [WmiDataId(4),
     Description("LoadFlags") : amended,
     format("x"),
     read]
     uint16  LoadFlags;
};

[Dynamic,
 Description("Virtual Allocations") : amended,
 EventType{98, 99},
 EventTypeName{"VirtualAlloc", "VirtualFree"} : amended
]
class PageFault_VirtualAlloc:PageFault_V2
{
    [WmiDataId(1),
     Description("BaseAddress") : amended,
     pointer,
     read]
     uint32  BaseAddress;
    [WmiDataId(2),
     Description("RegionSize") : amended,
     extension("SizeT"),
     read]
     object  RegionSize;
    [WmiDataId(3),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(4),
     Description("Flags") : amended,
     format("x"),
     read]
     uint32  Flags;
};

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

};

[Dynamic,
 Description("Heap Range Rundown Event") : amended,
 EventType(100),
 EventTypeName("HRRundown") : amended
]
class PageFault_HeapRangeRundown:PageFault
{
    [WmiDataId(1),
     Description("HeapHandle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("HRFlags") : amended,
     format("x"),
     read]
     uint32  HRFlags;
    [WmiDataId(3),
     Description("HRPid") : amended,
     format("x"),
     read]
     uint32  HRPid;
    [WmiDataId(4),
     Description("HRRangeCount") : amended,
     read]
     uint32  HRRangeCount;
    [WmiDataId(5),
     Description("Reserved") : amended,
     read]
     uint32  Reserved;
};


[Dynamic,
 Description("PerfInfo Event") : amended,
 Guid("{ce1dbfb4-137e-4da6-87b0-3f59aa102cbc}"),
 EventVersion(1),
 DisplayName("PerfInfo") : amended
]
class PerfInfo_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("ISR") : amended,
 EventType(67),
 EventTypeName("ISR") : amended
]
class ISR_V1:PerfInfo_V1
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
    [WmiDataId(3),
     Description("Return Value") : amended,
     read]
     uint32  ReturnValue;
};


[Dynamic,
 Description("DPC") : amended,
 EventType{68, 69},
 EventTypeName{"DPC", "TimerDPC"} : amended
]
class DPC_V1:PerfInfo_V1
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
};

[Dynamic,
 Description("PerfInfo Event") : amended,
 Guid("{ce1dbfb4-137e-4da6-87b0-3f59aa102cbc}"),
 EventVersion(2),
 DisplayName("PerfInfo") : amended
]
class PerfInfo:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Sampled Profile") : amended,
 EventType(46),
 EventTypeName("SampleProf") : amended
]
class SampledProfile:PerfInfo
{
    [WmiDataId(1),
     Description("InstructionPointer") : amended,
     pointer,
     read]
     uint32  InstructionPointer;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     read]
     uint32  ThreadId;
    [WmiDataId(3),
     Description("Count") : amended,
     read]
     uint16  Count;
    [WmiDataId(4),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
};

[Dynamic,
 Description("Sampled Profile Interval") : amended,
 EventType{72, 73, 74},
 EventTypeName{"SetInterval", "CollectionStart", "CollectionEnd"} : amended
]
class SampledProfileInterval:PerfInfo
{
    [WmiDataId(1),
     Description("Profile Source") : amended,
     read]
     uint32  Source;
    [WmiDataId(2),
     Description("New Interval") : amended,
     read]
     uint32  NewInterval;
    [WmiDataId(3),
     Description("Old Interval") : amended,
     read]
     uint32  OldInterval;
};



[Dynamic,
 Description("System Call Enter") : amended,
 EventType(51),
 EventTypeName("SysClEnter") : amended
]
class SysCallEnter:PerfInfo
{
    [WmiDataId(1),
     Description("SysCallAddress") : amended,
     pointer,
     read]
     uint32  SysCallAddress;
};

[Dynamic,
 Description("System Call Exit") : amended,
 EventType(52),
 EventTypeName("SysClExit") : amended
]
class SysCallExit:PerfInfo
{
    [WmiDataId(1),
     Description("SysCallNtStatus") : amended,
     format("x"),
     read]
     uint32  SysCallNtStatus;
};

[Dynamic,
 Description("ISR") : amended,
 EventType(67),
 EventTypeName("ISR") : amended
]
class ISR:PerfInfo
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
    [WmiDataId(3),
     Description("Return Value") : amended,
     read]
     uint8  ReturnValue;
    [WmiDataId(4),
     Description("Interrupt Vector") : amended,
     read]
     uint8  Vector;
    [WmiDataId(5),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
};

[Dynamic,
 Description("Message Signaled ISR") : amended,
 EventType(50),
 EventTypeName("ISR-MSI") : amended
]
class ISR_MSI:PerfInfo
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
    [WmiDataId(3),
     Description("Return Value") : amended,
     read]
     uint8  ReturnValue;
    [WmiDataId(4),
     Description("Interrupt Vector") : amended,
     read]
     uint8  Vector;
    [WmiDataId(5),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
    [WmiDataId(6),
     Description("Message Number") : amended,
     read]
     uint32  MessageNumber;
};


[Dynamic,
 Description("DPC") : amended,
 EventType{66, 68, 69},
 EventTypeName{"ThreadedDPC", "DPC", "TimerDPC"} : amended
]
class DPC:PerfInfo
{
    [WmiDataId(1),
     Description("Initial Time") : amended,
     extension("WmiTime"),
     read]
     object  InitialTime;
    [WmiDataId(2),
     Description("Routine") : amended,
     pointer,
     read]
     uint32  Routine;
};

[Dynamic,
 Description("Debugger Enabled") : amended,
 EventType{58},
 EventTypeName{"DebuggerEnabled"} : amended
]
class DebuggerEnabled:PerfInfo
{
};

[Dynamic,
 Description("StackWalk Event") : amended,
 Guid("{def2fe46-7bd6-4b80-bd94-f57fe20d0ce3}"),
 DisplayName("StackWalk") : amended
]
class StackWalk:MSNT_SystemTrace
{

};

[Dynamic,
 Description("StackWalk Event") : amended,
 EventType(32),
 EventTypeName("Stack") : amended
]
class StackWalk_Event:StackWalk
{
    [WmiDataId(1),
     Description("TimeStamp") : amended,
     read]
     uint64  EventTimeStamp;
    [WmiDataId(2),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  StackProcess;
    [WmiDataId(3),
     Description("ThreadId") : amended,
     read]
     uint32  StackThread;
    [WmiDataId(4),
     Description("Stack1") : amended,
     pointer,
     read]
     uint32  Stack1;
    [WmiDataId(5),
     Description("Stack2") : amended,
     pointer,
     read]
     uint32  Stack2;
    [WmiDataId(6),
     Description("Stack3") : amended,
     pointer,
     read]
     uint32  Stack3;
    [WmiDataId(7),
     Description("Stack4") : amended,
     pointer,
     read]
     uint32  Stack4;
    [WmiDataId(8),
     Description("Stack5") : amended,
     pointer,
     read]
     uint32  Stack5;
    [WmiDataId(9),
     Description("Stack6") : amended,
     pointer,
     read]
     uint32  Stack6;
    [WmiDataId(10),
     Description("Stack7") : amended,
     pointer,
     read]
     uint32  Stack7;
    [WmiDataId(11),
     Description("Stack8") : amended,
     pointer,
     read]
     uint32  Stack8;
    [WmiDataId(12),
     Description("Stack9") : amended,
     pointer,
     read]
     uint32  Stack9;
    [WmiDataId(13),
     Description("Stack10") : amended,
     pointer,
     read]
     uint32  Stack10;
    [WmiDataId(14),
     Description("Stack11") : amended,
     pointer,
     read]
     uint32  Stack11;
    [WmiDataId(15),
     Description("Stack12") : amended,
     pointer,
     read]
     uint32  Stack12;
    [WmiDataId(16),
     Description("Stack13") : amended,
     pointer,
     read]
     uint32  Stack13;
    [WmiDataId(17),
     Description("Stack14") : amended,
     pointer,
     read]
     uint32  Stack14;
    [WmiDataId(18),
     Description("Stack15") : amended,
     pointer,
     read]
     uint32  Stack15;
    [WmiDataId(19),
     Description("Stack16") : amended,
     pointer,
     read]
     uint32  Stack16;
    [WmiDataId(20),
     Description("Stack17") : amended,
     pointer,
     read]
     uint32  Stack17;
    [WmiDataId(21),
     Description("Stack18") : amended,
     pointer,
     read]
     uint32  Stack18;
    [WmiDataId(22),
     Description("Stack19") : amended,
     pointer,
     read]
     uint32  Stack19;
    [WmiDataId(23),
     Description("Stack20") : amended,
     pointer,
     read]
     uint32  Stack20;
    [WmiDataId(24),
     Description("Stack21") : amended,
     pointer,
     read]
     uint32  Stack21;
    [WmiDataId(25),
     Description("Stack22") : amended,
     pointer,
     read]
     uint32  Stack22;
    [WmiDataId(26),
     Description("Stack23") : amended,
     pointer,
     read]
     uint32  Stack23;
    [WmiDataId(27),
     Description("Stack24") : amended,
     pointer,
     read]
     uint32  Stack24;
    [WmiDataId(28),
     Description("Stack25") : amended,
     pointer,
     read]
     uint32  Stack25;
    [WmiDataId(29),
     Description("Stack26") : amended,
     pointer,
     read]
     uint32  Stack26;
    [WmiDataId(30),
     Description("Stack27") : amended,
     pointer,
     read]
     uint32  Stack27;
    [WmiDataId(31),
     Description("Stack28") : amended,
     pointer,
     read]
     uint32  Stack28;
    [WmiDataId(32),
     Description("Stack29") : amended,
     pointer,
     read]
     uint32  Stack29;
    [WmiDataId(33),
     Description("Stack30") : amended,
     pointer,
     read]
     uint32  Stack30;
    [WmiDataId(34),
     Description("Stack31") : amended,
     pointer,
     read]
     uint32  Stack31;
    [WmiDataId(35),
     Description("Stack32") : amended,
     pointer,
     read]
     uint32  Stack32;

};


[Dynamic,
 Description("ALPC Event") : amended,
 Guid("{45d8cccd-539f-4b72-a8b7-5c683142609a}"),
 DisplayName("ALPC") : amended
]
class ALPC:MSNT_SystemTrace
{

};

[Dynamic,
 Description("ALPC Send Message") : amended,
 EventType(33),
 EventTypeName("ALPC-Send-Message") : amended
]
class ALPC_Send_Message:ALPC
{
    [WmiDataId(1),
     Description("MessageID") : amended,
     read]
     uint32  MessageID;
};

[Dynamic,
 Description("ALPC Receive Message") : amended,
 EventType(34),
 EventTypeName("ALPC-Receive-Message") : amended
]
class ALPC_Receive_Message:ALPC
{
    [WmiDataId(1),
     Description("MessageID") : amended,
     read]
     uint32  MessageID;
};

[Dynamic,
 Description("ALPC Wait For Reply") : amended,
 EventType(35),
 EventTypeName("ALPC-Wait-For-Reply") : amended
]
class ALPC_Wait_For_Reply:ALPC
{
    [WmiDataId(1),
     Description("MessageID") : amended,
     read]
     uint32  MessageID;
};

[Dynamic,
 Description("ALPC Wait For New Message") : amended,
 EventType(36),
 EventTypeName("ALPC-Wait-For-New-Message") : amended
]
class ALPC_Wait_For_New_Message:ALPC
{
    [WmiDataId(1),
     Description("IsServerPort") : amended,
     read]
     uint32  IsServerPort;
    [WmiDataId(2),
     Description("PortName") : amended,
     read]
     string  PortName;
};

[Dynamic,
 Description("ALPC Unwait") : amended,
 EventType(37),
 EventTypeName("ALPC-Unwait") : amended
]
class ALPC_Unwait:ALPC
{
    [WmiDataId(1),
     Description("Status") : amended,
     read]
     uint32  Status;
};

[Dynamic,
 Description("Heap Trace Provider"): amended,
 Guid("{222962ab-6180-4b88-a825-346b75f2a24a}")
]
class HeapTraceProvider:EventTrace
{

};

[Dynamic,
 Description("Heap Event") : amended,
 Guid("{222962ab-6180-4b88-a825-346b75f2a24a}"),
 EventVersion(2),       
 DisplayName("Heap") : amended
]
class HeapTrace_V2:HeapTraceProvider
{

};

[Dynamic,
 Description("Heap Create") : amended,
 EventType(32),
 EventTypeName("Create") : amended
]
class HeapCreate_V2:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Heap Flags") : amended,
     read]
     uint32  HeapFlags;
};

[Dynamic,
 Description("Heap Allocate") : amended,
 EventType(33),
 EventTypeName("Alloc") : amended
]
class HeapAlloc:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Allocation Size") : amended,
     extension("SizeT"),
     read]
     object  AllocSize;
    [WmiDataId(3),
     Description("Allocation Address") : amended,
     pointer,
     read]
     uint32  AllocAddress;
    [WmiDataId(4),
     Description("Source ID") : amended,
     read]
     uint32  SourceId;
};

[Dynamic,
 Description("Heap ReAllocate") : amended,
 EventType(34),
 EventTypeName("ReAlloc") : amended
]
class HeapRealloc:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("New Allocation Address") : amended,
     pointer,
     read]
     uint32  NewAllocAddress;
    [WmiDataId(3),
     Description("Old Allocation Address") : amended,
     pointer,
     read]
     uint32  OldAllocAddress;
    [WmiDataId(4),
     Description("New Allocation Size") : amended,
     extension("SizeT"),
     read]
     object  NewAllocSize;
    [WmiDataId(5),
     Description("Old Allocation Size") : amended,
     extension("SizeT"),
     read]
     object  OldAllocSize;
    [WmiDataId(6),
     Description("Source ID") : amended,
     read]
     uint32  SourceId;
};

[Dynamic,
 Description("Heap Free") : amended,
 EventType(36),
 EventTypeName("Free") : amended
]
class HeapFree:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Free Address") : amended,
     pointer,
     read]
     uint32  FreeAddress;
    [WmiDataId(3),
     Description("Source ID") : amended,
     read]
     uint32  SourceId;
};

[Dynamic,
 Description("Heap SnapShot") : amended,
 EventType(38),
 EventTypeName("SnapShot") : amended
]
class HeapSnapShot_V2:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Free Space") : amended,
     extension("SizeT"),
     read]
     object  FreeSpace;
    [WmiDataId(3),
     Description("Committed Space") : amended,
     extension("SizeT"),
     read]
     object  CommittedSpace;
    [WmiDataId(4),
     Description("Reserved Space") : amended,
     extension("SizeT"),
     read]
     object  ReservedSpace;
    [WmiDataId(5),
     Description("Heap Flags") : amended,
     read]
     uint32  HeapFlags;
    [WmiDataId(6),
     Description("Process ID") : amended,
     read]
     uint32  ProcessId;
    [WmiDataId(7),
     Description("Large UCR Space") : amended,
     extension("SizeT"),
     read]
     object  LargeUCRSpace;
    [WmiDataId(8),
     Description("Free List Length") : amended,
     read]
     uint32  FreeListLength;    
    [WmiDataId(9),
     Description("UCR Length") : amended,
     read]
     uint32  UCRLength;
};

[Dynamic,
 Description("Heap Events") : amended,
 EventType{35, 43, 44, 45, 46},
 EventTypeName{"Destroy", "Lock", "Unlock", "Validate", "Walk"} : amended
]
class Heap_TypeGroup1:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
};

[Dynamic,
 Description("Heap Subsegment Events") : amended,
 EventType{47, 48, 49, 50},
 EventTypeName{"SubsegmentAlloc", "SubsegmentFree", "SubsegmentAllocCached", "SubsegmentFreeCached"} : amended
]
class Heap_SubsegmentGroup:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Subsegment") : amended,
     pointer,
     read]
     uint32  SubSegment;
    [WmiDataId(3),
     Description("Subsegment Size") : amended,
     extension("SizeT"),
     read]
     object  SubSegmentSize;
    [WmiDataId(4),
     Description("Block Size") : amended,
     extension("SizeT"),
     read]
     object  BlockSize;
};

[Dynamic,
 Description("Heap Commit and Decommit") : amended,
 EventType{51, 52},
 EventTypeName{"Commit", "Decommit"} : amended
]
class HeapCommitDecommit:HeapTrace_V2
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Block Address") : amended,
     pointer,
     read]
     uint32  Block;
    [WmiDataId(3),
     Description("Block Size") : amended,
     extension("SizeT"),
     read]
     object  Size;
    [WmiDataId(4),
     Description("Caller") : amended,
     read]
     uint32  Caller;
};

[Dynamic,
 Description("Heap Event") : amended,
 Guid("{222962ab-6180-4b88-a825-346b75f2a24a}"),
 EventVersion(3),
 DisplayName("Heap") : amended
]
class HeapTrace:HeapTraceProvider
{

};

[Dynamic,
 Description("Heap Create") : amended,
 EventType(32),
 EventTypeName("Create") : amended
]
class HeapCreate:HeapTrace
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Heap Flags") : amended,
     read]
     uint32  HeapFlags;
    [WmiDataId(3),
     Description("Reserved Space") : amended,
     extension("SizeT"),
     read]
     object  ReservedSpace;
    [WmiDataId(4),
     Description("Committed Space") : amended,
     extension("SizeT"),
     read]
     object  CommittedSpace;
    [WmiDataId(5),
     Description("Allocated Size") : amended,
     extension("SizeT"),
     read]
     object  AllocatedSpace;
};

[Dynamic,
 Description("Heap Expand") : amended,
 EventType(37),
 EventTypeName("Expand") : amended
]
class HeapExpand:HeapTrace
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Committed Size") : amended,
     extension("SizeT"),
     read]
     object  CommittedSize;
    [WmiDataId(3),
     Description("Committed Address") : amended,
     pointer,
     read]
     uint32  CommitAddress;
    [WmiDataId(4),
     Description("Free Space") : amended,
     extension("SizeT"),
     read]
     object  FreeSpace;
    [WmiDataId(5),
     Description("Committed Space") : amended,
     extension("SizeT"),
     read]
     object  CommittedSpace;
    [WmiDataId(6),
     Description("Reserved Space") : amended,
     extension("SizeT"),
     read]
     object  ReservedSpace;
    [WmiDataId(7),
     Description("Number Of UCRs") : amended,
     read]
     uint32  NoOfUCRs;
    [WmiDataId(8),
     Description("Allocated Space") : amended,
     extension("SizeT"),
     read]
     object  AllocatedSpace;
};

[Dynamic,
 Description("Heap SnapShot") : amended,
 EventType(38),
 EventTypeName("SnapShot") : amended
]
class HeapSnapShot:HeapTrace
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("Free Space") : amended,
     extension("SizeT"),
     read]
     object  FreeSpace;
    [WmiDataId(3),
     Description("Committed Space") : amended,
     extension("SizeT"),
     read]
     object  CommittedSpace;
    [WmiDataId(4),
     Description("Reserved Space") : amended,
     extension("SizeT"),
     read]
     object  ReservedSpace;
    [WmiDataId(5),
     Description("Heap Flags") : amended,
     read]
     uint32  HeapFlags;
    [WmiDataId(6),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
   [WmiDataId(7),
     Description("Large UCR Space") : amended,
     extension("SizeT"),
     read]
     object  LargeUCRSpace;
    [WmiDataId(8),
     Description("Free List Length") : amended,
     read]
     uint32  FreeListLength;
    [WmiDataId(9),
     Description("UCR Length") : amended,
     read]
     uint32  UCRLength;
    [WmiDataId(10),
     Description("Allocated Space") : amended,
     extension("SizeT"),
     read]
     object  AllocatedSpace;
};

[Dynamic,
 Description("Heap Contract") : amended,
 EventType(42),
 EventTypeName("Contract") : amended
]
class HeapContract:HeapTrace
{
    [WmiDataId(1),
     Description("Heap Handle") : amended,
     pointer,
     read]
     uint32  HeapHandle;
    [WmiDataId(2),
     Description("DeCommitted Size") : amended,
     extension("SizeT"),
     read]
     object  DeCommittedSize;
    [WmiDataId(3),
     Description("DeCommitted Address") : amended,
     pointer,
     read]
     uint32  DeCommitAddress;
    [WmiDataId(4),
     Description("Free Space") : amended,
     extension("SizeT"),
     read]
     object  FreeSpace;
    [WmiDataId(5),
     Description("Committed Space") : amended,
     extension("SizeT"),
     read]
     object  CommittedSpace;
    [WmiDataId(6),
     Description("Reserved Space") : amended,
     extension("SizeT"),
     read]
     object  ReservedSpace;
    [WmiDataId(7),
     Description("Number Of UCRs") : amended,
     read]
     uint32  NoOfUCRs;
    [WmiDataId(8),
     Description("Allocated Space") : amended,
     extension("SizeT"),
     read]
     object  AllocatedSpace;
};


[Dynamic,
 Description("Critical Section Trace Provider") : amended,
 Guid("{3AC66736-CC59-4cff-8115-8DF50E39816B}")
]
class CritSecTraceProvider:EventTrace
{

};

[Dynamic,
 Description("Critical Section Event") : amended,
 Guid("{3AC66736-CC59-4cff-8115-8DF50E39816B}"),
 DisplayName("CritSec") : amended
]
class CritSecTrace:CritSecTraceProvider
{

};

[Dynamic,
 Description("Critical Section Collision") : amended,
 EventType(34),
 EventTypeName("Collision") : amended
]
class CritSecCollision:CritSecTrace
{
    [WmiDataId(1),
     Description("Lock Count") : amended,
     read]
     uint32  LockCount;
    [WmiDataId(2),
     Description("Spin Count") : amended,
     read]
     uint32  SpinCount;
    [WmiDataId(3),
     Description("Owning Thread") : amended,
     pointer,
     read]
     uint32  OwningThread;
    [WmiDataId(4),
     Description("Critical Section Address") : amended,
     pointer,
     read]
     uint32  CritSecAddr;
};

[Dynamic,
 Description("Critical Section Initialize") : amended,
 EventType(35),
 EventTypeName("Initialize") : amended
]
class CritSecInit:CritSecTrace
{
    [WmiDataId(1),
     Description("Spin Count") : amended,
     pointer,
     read]
     uint32  SpinCount;
    [WmiDataId(2),
     Description("Critical Section Address") : amended,
     pointer,
     read]
     uint32  CritSecAddr;
};

[Dynamic,
 Description("Lost Event Event") : amended,
 Guid("{6a399ae0-4bc6-4de9-870b-3657f8947e7e}"),
 DisplayName("LostEvent") : amended
]
class Lost_Event:MSNT_SystemTrace
{
};

[Dynamic,
 Description("RT Lost Event") : amended,
 EventType{32, 33, 34},
 EventTypeName{"RTLostEvent", "RTLostBuffer", "RTLostFile"} : amended
]
class RT_LostEvent:Lost_Event
{
};


[Dynamic,
 Description("System Configuration") : amended,
 Guid("{01853a65-418f-4f36-aefc-dc0f1d2fd235}"),
 EventVersion(0),
 DisplayName("SystemConfig") : amended
]
class SystemConfig_V0:MSNT_SystemTrace
{

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(10),
 EventTypeName("CPU") : amended
]
class SystemConfig_V0_CPU:SystemConfig_V0
{
    [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,
     read]
     char16  ComputerName[256];
    [WmiDataId(7),
     Description("DomainName") : amended,
     read]
     char16  DomainName[132];
    [WmiDataId(8),
     Description("HyperThreadingFlag") : amended,
     pointer,
     read]
     uint32  HyperThreadingFlag;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(11),
 EventTypeName("PhyDisk") : amended
]
class SystemConfig_V0_PhyDisk:SystemConfig_V0
{
    [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,
     read]
     char16  Manufacturer[256];
    [WmiDataId(11),
     Description("PartitionCount") : amended,
     read]
     uint32  PartitionCount;
    [WmiDataId(12),
     Description("WriteCacheEnabled") : amended,
     read]
     uint8  WriteCacheEnabled;
    [WmiDataId(13),
     Description("Pad: not used") : amended,
     read]
     uint8  Pad;
    [WmiDataId(14),
     Description("BootDriveLetter") : amended,
     read]
     char16  BootDriveLetter[3];
    [WmiDataId(15),
     Description("Spare") : amended,
     read]
     char16  Spare[2];
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(12),
 EventTypeName("LogDisk") : amended
]
class SystemConfig_V0_LogDisk:SystemConfig_V0
{
    [WmiDataId(1),
     Description("StartOffset") : amended,
     read]
     uint64  StartOffset;
    [WmiDataId(2),
     Description("PartitionSize") : amended,
     read]
     uint64  PartitionSize;
    [WmiDataId(3),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(4),
     Description("Size") : amended,
     read]
     uint32  Size;
    [WmiDataId(5),
     Description("DriveType") : amended,
     read]
     uint32  DriveType;
    [WmiDataId(6),
     Description("DriveLetter") : amended,
     read]
     char16  DriveLetterString[4];
    [WmiDataId(7),
     Description("Pad1") : amended,
     read]
     uint32  Pad1;
    [WmiDataId(8),
     Description("PartitionNumber") : amended,
     read]
     uint32  PartitionNumber;
    [WmiDataId(9),
     Description("SectorsPerCluster") : amended,
     read]
     uint32  SectorsPerCluster;
    [WmiDataId(10),
     Description("BytesPerSector") : amended,
     read]
     uint32  BytesPerSector;
    [WmiDataId(11),
     Description("Pad2") : amended,
     read]
     uint32  Pad2;
    [WmiDataId(12),
     Description("NumberOfFreeClusters") : amended,
     read]
     sint64  NumberOfFreeClusters;
    [WmiDataId(13),
     Description("TotalNumberOfClusters") : amended,
     read]
     sint64  TotalNumberOfClusters;
    [WmiDataId(14),
     Description("FileSystem") : amended,
     read]
     char16 FileSystem[16];
    [WmiDataId(15),
     Description("VolumeExtent") : amended,
     read]
     uint32  VolumeExt;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(13),
 EventTypeName("NIC") : amended
]
class SystemConfig_V0_NIC:SystemConfig_V0
{
    [WmiDataId(1),
     Description("NICName") : amended,
     read]
     char16  NICName[256];
    [WmiDataId(2),
     Description("Index") : amended,
     read]
     uint32  Index;
    [WmiDataId(3),
     Description("PhysicalAddressLen") : amended,
     read]
     uint32  PhysicalAddrLen;
    [WmiDataId(4),
     Description("PhysicalAddress") : amended,
     read]
     char16  PhysicalAddr[8];
    [WmiDataId(5),
     Description("Size") : amended,
     read]
     uint32  Size;
    [WmiDataId(6),
     Description("IpAddress") : amended,
     read]
     sint32  IpAddress;
    [WmiDataId(7),
     Description("SubnetMask") : amended,
     read]
     sint32  SubnetMask;
    [WmiDataId(8),
     Description("DhcpServer") : amended,
     read]
     sint32  DhcpServer;
    [WmiDataId(9),
     Description("Gateway") : amended,
     read]
     sint32  Gateway;
    [WmiDataId(10),
     Description("PrimaryWinsServer") : amended,
     read]
     sint32  PrimaryWinsServer;
    [WmiDataId(11),
     Description("SecondaryWinsServer") : amended,
     read]
     sint32  SecondaryWinsServer;
    [WmiDataId(12),
     Description("DnsServer1") : amended,
     read]
     sint32  DnsServer1;
    [WmiDataId(13),
     Description("DnsServer2") : amended,
     read]
     sint32  DnsServer2;
    [WmiDataId(14),
     Description("DnsServer3") : amended,
     read]
     sint32  DnsServer3;
    [WmiDataId(15),
     Description("DnsServer4") : amended,
     read]
     sint32  DnsServer4;
    [WmiDataId(16),
     Description("Reserved; do not use.") : amended,
     read]
     uint32 Data;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(14),
 EventTypeName("Video") : amended
]
class SystemConfig_V0_Video:SystemConfig_V0
{
    [WmiDataId(1),
     Description("MemorySize") : amended,
     read]
     uint32  MemorySize;
    [WmiDataId(2),
     Description("XResolution") : amended,
     read]
     uint32  XResolution;
    [WmiDataId(3),
     Description("YResolution") : amended,
     read]
     uint32  YResolution;
    [WmiDataId(4),
     Description("BitsPerPixel") : amended,
     read]
     uint32  BitsPerPixel;
    [WmiDataId(5),
     Description("VRefresh") : amended,
     read]
     uint32  VRefresh;
    [WmiDataId(6),
     Description("ChipType") : amended,
     read]
     char16  ChipType[256];
    [WmiDataId(7),
     Description("DACType") : amended,
     read]
     char16  DACType[256];
    [WmiDataId(8),
     Description("AdapterString") : amended,
     read]
     char16  AdapterString[256];
    [WmiDataId(9),
     Description("BiosString") : amended,
     read]
     char16  BiosString[256];
    [WmiDataId(10),
     Description("Device Name") : amended,
     read]
     char16  DeviceId[256];
    [WmiDataId(11),
     Description("StateFlags") : amended,
     format("x"),
     read]
     uint32  StateFlags;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(15),
 EventTypeName("Services") : amended
]
class SystemConfig_V0_Services:SystemConfig_V0
{
    [WmiDataId(1),
     Description("ServiceName") : amended,
     read]
     char16  ServiceName[34];
    [WmiDataId(2),
     Description("DisplayName") : amended,
     read]
     char16  DisplayName[256];
    [WmiDataId(3),
     Description("ProcessName") : amended,
     read]
     char16  ProcessName[34];
    [WmiDataId(4),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(16),
 EventTypeName("Power") : amended
]
class SystemConfig_V0_Power:SystemConfig_V0
{
    [WmiDataId(1),
     Description("S1") : amended,
     read]
     uint8  S1;
    [WmiDataId(2),
     Description("S2") : amended,
     read]
     uint8  S2;
    [WmiDataId(3),
     Description("S3") : amended,
     read]
     uint8  S3;
    [WmiDataId(4),
     Description("S4") : amended,
     read]
     uint8  S4;
    [WmiDataId(5),
     Description("S5") : amended,
     read]
     uint8  S5;
    [WmiDataId(6),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad1;
    [WmiDataId(7),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad2;
    [WmiDataId(8),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad3;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(21),
 EventTypeName("IRQ") : amended
]
class SystemConfig_V0_IRQ:SystemConfig_V0
{
    [WmiDataId(1),
     Description("IRQAffinity") : amended,
     format("x"),
     read]
    uint64  IRQAffinity;
    [WmiDataId(2),
     Description("IRQNum") : amended,
     read]
    uint32 IRQNum;
    [WmiDataId(3),
     Description("DeviceDescriptionLen") : amended,
     read]
    uint32 DeviceDescriptionLen;
    [WmiDataId(4),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceDescription;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(22),
 EventTypeName("PnP") : amended
]
class SystemConfig_V0_PnP:SystemConfig_V0
{
    [WmiDataId(1),
     Description("IDLength") : amended,
     read]
    uint32  IDLength;
    [WmiDataId(2),
     Description("DescriptionLength") : amended,
     read]
    uint32 DescriptionLength;
    [WmiDataId(3),
     Description("FriendlyNameLength") : amended,
     read]
    uint32 FriendlyNameLength;
    [WmiDataId(4),
     Description("DeviceID") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceID;
    [WmiDataId(5),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceDescription;
    [WmiDataId(6),
     Description("FriendlyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string FriendlyName;
};

[Dynamic,
 Description("System Configuration") : amended,
 Guid("{01853a65-418f-4f36-aefc-dc0f1d2fd235}"),
 EventVersion(1),
 DisplayName("SystemConfig") : amended
]
class SystemConfig_V1:MSNT_SystemTrace
{

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(10),
 EventTypeName("CPU") : amended
]
class SystemConfig_V1_CPU:SystemConfig_V1
{
    [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,
     read]
     char16  ComputerName[256];
    [WmiDataId(7),
     Description("DomainName") : amended,
     read]
     char16  DomainName[132];
    [WmiDataId(8),
     Description("HyperThreadingFlag") : amended,
     pointer,
     read]
     uint32  HyperThreadingFlag;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(11),
 EventTypeName("PhyDisk") : amended
]
class SystemConfig_V1_PhyDisk:SystemConfig_V1
{
    [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,
     read]
     char16  Manufacturer[256];
    [WmiDataId(11),
     Description("PartitionCount") : amended,
     read]
     uint32  PartitionCount;
    [WmiDataId(12),
     Description("WriteCacheEnabled") : amended,
     read]
     uint8  WriteCacheEnabled;
    [WmiDataId(13),
     Description("Pad: not used") : amended,
     read]
     uint8  Pad;
    [WmiDataId(14),
     Description("BootDriveLetter") : amended,
     read]
     char16  BootDriveLetter[3];
    [WmiDataId(15),
     Description("Spare") : amended,
     read]
     char16  Spare[2];
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(12),
 EventTypeName("LogDisk") : amended
]
class SystemConfig_V1_LogDisk:SystemConfig_V1
{
    [WmiDataId(1),
     Description("StartOffset") : amended,
     read]
     uint64  StartOffset;
    [WmiDataId(2),
     Description("PartitionSize") : amended,
     read]
     uint64  PartitionSize;
    [WmiDataId(3),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(4),
     Description("Size") : amended,
     read]
     uint32  Size;
    [WmiDataId(5),
     Description("DriveType") : amended,
     read]
     uint32  DriveType;
    [WmiDataId(6),
     Description("DriveLetter") : amended,
     read]
     char16  DriveLetterString[4];
    [WmiDataId(7),
     Description("Pad1") : amended,
     read]
     uint32  Pad1;
    [WmiDataId(8),
     Description("PartitionNumber") : amended,
     read]
     uint32  PartitionNumber;
    [WmiDataId(9),
     Description("SectorsPerCluster") : amended,
     read]
     uint32  SectorsPerCluster;
    [WmiDataId(10),
     Description("BytesPerSector") : amended,
     read]
     uint32  BytesPerSector;
    [WmiDataId(11),
     Description("Pad2") : amended,
     read]
     uint32  Pad2;
    [WmiDataId(12),
     Description("NumberOfFreeClusters") : amended,
     read]
     sint64  NumberOfFreeClusters;
    [WmiDataId(13),
     Description("TotalNumberOfClusters") : amended,
     read]
     sint64  TotalNumberOfClusters;
    [WmiDataId(14),
     Description("FileSystem") : amended,
     read]
     char16 FileSystem[16];
    [WmiDataId(15),
     Description("VolumeExtent") : amended,
     read]
     uint32  VolumeExt;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(13),
 EventTypeName("NIC") : amended
]
class SystemConfig_V1_NIC:SystemConfig_V1
{
    [WmiDataId(1),
     Description("NICName") : amended,
     read]
     char16  NICName[256];
    [WmiDataId(2),
     Description("Index") : amended,
     read]
     uint32  Index;
    [WmiDataId(3),
     Description("PhysicalAddressLen") : amended,
     read]
     uint32  PhysicalAddrLen;
    [WmiDataId(4),
     Description("PhysicalAddress") : amended,
     read]
     char16  PhysicalAddr[8];
    [WmiDataId(5),
     Description("Size") : amended,
     read]
     uint32  Size;
    [WmiDataId(6),
     Description("IpAddress") : amended,
     read]
     sint32  IpAddress;
    [WmiDataId(7),
     Description("SubnetMask") : amended,
     read]
     sint32  SubnetMask;
    [WmiDataId(8),
     Description("DhcpServer") : amended,
     read]
     sint32  DhcpServer;
    [WmiDataId(9),
     Description("Gateway") : amended,
     read]
     sint32  Gateway;
    [WmiDataId(10),
     Description("PrimaryWinsServer") : amended,
     read]
     sint32  PrimaryWinsServer;
    [WmiDataId(11),
     Description("SecondaryWinsServer") : amended,
     read]
     sint32  SecondaryWinsServer;
    [WmiDataId(12),
     Description("DnsServer1") : amended,
     read]
     sint32  DnsServer1;
    [WmiDataId(13),
     Description("DnsServer2") : amended,
     read]
     sint32  DnsServer2;
    [WmiDataId(14),
     Description("DnsServer3") : amended,
     read]
     sint32  DnsServer3;
    [WmiDataId(15),
     Description("DnsServer4") : amended,
     read]
     sint32  DnsServer4;
    [WmiDataId(16),
     Description("Reserved; do not use.") : amended,
     read]
     uint32 Data;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(14),
 EventTypeName("Video") : amended
]
class SystemConfig_V1_Video:SystemConfig_V1
{
    [WmiDataId(1),
     Description("MemorySize") : amended,
     read]
     uint32  MemorySize;
    [WmiDataId(2),
     Description("XResolution") : amended,
     read]
     uint32  XResolution;
    [WmiDataId(3),
     Description("YResolution") : amended,
     read]
     uint32  YResolution;
    [WmiDataId(4),
     Description("BitsPerPixel") : amended,
     read]
     uint32  BitsPerPixel;
    [WmiDataId(5),
     Description("VRefresh") : amended,
     read]
     uint32  VRefresh;
    [WmiDataId(6),
     Description("ChipType") : amended,
     read]
     char16  ChipType[256];
    [WmiDataId(7),
     Description("DACType") : amended,
     read]
     char16  DACType[256];
    [WmiDataId(8),
     Description("AdapterString") : amended,
     read]
     char16  AdapterString[256];
    [WmiDataId(9),
     Description("BiosString") : amended,
     read]
     char16  BiosString[256];
    [WmiDataId(10),
     Description("Device Name") : amended,
     read]
     char16  DeviceId[256];
    [WmiDataId(11),
     Description("StateFlags") : amended,
     format("x"),
     read]
     uint32  StateFlags;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(15),
 EventTypeName("Services") : amended
]
class SystemConfig_V1_Services:SystemConfig_V1
{
    [WmiDataId(1),
     Description("ServiceName") : amended,
     read]
     char16  ServiceName[34];
    [WmiDataId(2),
     Description("DisplayName") : amended,
     read]
     char16  DisplayName[256];
    [WmiDataId(3),
     Description("ProcessName") : amended,
     read]
     char16  ProcessName[34];
    [WmiDataId(4),
     Description("ProcessId") : amended,
     read]
     uint32  ProcessId;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(16),
 EventTypeName("Power") : amended
]
class SystemConfig_V1_Power:SystemConfig_V1
{
    [WmiDataId(1),
     Description("S1") : amended,
     read]
     uint8  S1;
    [WmiDataId(2),
     Description("S2") : amended,
     read]
     uint8  S2;
    [WmiDataId(3),
     Description("S3") : amended,
     read]
     uint8  S3;
    [WmiDataId(4),
     Description("S4") : amended,
     read]
     uint8  S4;
    [WmiDataId(5),
     Description("S5") : amended,
     read]
     uint8  S5;
    [WmiDataId(6),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad1;
    [WmiDataId(7),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad2;
    [WmiDataId(8),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad3;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(21),
 EventTypeName("IRQ") : amended
]
class SystemConfig_V1_IRQ:SystemConfig_V1
{
    [WmiDataId(1),
     Description("IRQAffinity") : amended,
     format("x"),
     read]
    uint64  IRQAffinity;
    [WmiDataId(2),
     Description("IRQNum") : amended,
     read]
    uint32 IRQNum;
    [WmiDataId(3),
     Description("DeviceDescriptionLen") : amended,
     read]
    uint32 DeviceDescriptionLen;
    [WmiDataId(4),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceDescription;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(22),
 EventTypeName("PnP") : amended
]
class SystemConfig_V1_PnP:SystemConfig_V1
{
    [WmiDataId(1),
     Description("IDLength") : amended,
     read]
    uint32  IDLength;
    [WmiDataId(2),
     Description("DescriptionLength") : amended,
     read]
    uint32 DescriptionLength;
    [WmiDataId(3),
     Description("FriendlyNameLength") : amended,
     read]
    uint32 FriendlyNameLength;
    [WmiDataId(4),
     Description("DeviceID") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceID;
    [WmiDataId(5),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string DeviceDescription;
    [WmiDataId(6),
     Description("FriendlyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
    string FriendlyName;
};

[Dynamic,
 Description("System Configuration") : amended,
 Guid("{01853a65-418f-4f36-aefc-dc0f1d2fd235}"),
 EventVersion(2),
 DisplayName("SystemConfig") : amended
]
class SystemConfig_V2:MSNT_SystemTrace
{

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(10),
 EventTypeName("CPU") : amended
]
class SystemConfig_V2_CPU:SystemConfig_V2
{
    [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,
     format("s"),
     read]
     char16  ComputerName[256];
    [WmiDataId(7),
     Description("DomainName") : amended,
     format("s"),
     read]
     char16  DomainName[134];
    [WmiDataId(8),
     Description("HyperThreadingFlag") : amended,
     pointer,
     read]
     uint32  HyperThreadingFlag;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(11),
 EventTypeName("PhyDisk") : amended
]
class SystemConfig_V2_PhyDisk:SystemConfig_V2
{
    [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,
     format("s"),
     read]
     char16  Manufacturer[256];
    [WmiDataId(11),
     Description("PartitionCount") : amended,
     read]
     uint32  PartitionCount;
    [WmiDataId(12),
     Description("WriteCacheEnabled") : amended,
     read]
     uint8  WriteCacheEnabled;
    [WmiDataId(13),
     Description("Pad: not used") : amended,
     read]
     uint8  Pad;
    [WmiDataId(14),
     Description("BootDriveLetter") : amended,
     format("s"),
     read]
     char16  BootDriveLetter[3];
    [WmiDataId(15),
     Description("Spare") : amended,
     read]
     char16  Spare[2];
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(12),
 EventTypeName("LogDisk") : amended
]
class SystemConfig_V2_LogDisk:SystemConfig_V2
{
    [WmiDataId(1),
     Description("StartOffset") : amended,
     read]
     uint64  StartOffset;
    [WmiDataId(2),
     Description("PartitionSize") : amended,
     read]
     uint64  PartitionSize;
    [WmiDataId(3),
     Description("DiskNumber") : amended,
     read]
     uint32  DiskNumber;
    [WmiDataId(4),
     Description("Size") : amended,
     read]
     uint32  Size;
    [WmiDataId(5),
     Description("DriveType") : amended,
     read]
     uint32  DriveType;
    [WmiDataId(6),
     Description("DriveLetter") : amended,
     format("s"),
     read]
     char16  DriveLetterString[4];
    [WmiDataId(7),
     Description("Pad1") : amended,
     read]
     uint32  Pad1;
    [WmiDataId(8),
     Description("PartitionNumber") : amended,
     read]
     uint32  PartitionNumber;
    [WmiDataId(9),
     Description("SectorsPerCluster") : amended,
     read]
     uint32  SectorsPerCluster;
    [WmiDataId(10),
     Description("BytesPerSector") : amended,
     read]
     uint32  BytesPerSector;
    [WmiDataId(11),
     Description("Pad2") : amended,
     read]
     uint32  Pad2;
    [WmiDataId(12),
     Description("NumberOfFreeClusters") : amended,
     read]
     sint64  NumberOfFreeClusters;
    [WmiDataId(13),
     Description("TotalNumberOfClusters") : amended,
     read]
     sint64  TotalNumberOfClusters;
    [WmiDataId(14),
     Description("FileSystem") : amended,
     format("s"),
     read]
     char16 FileSystem[16];
    [WmiDataId(15),
     Description("VolumeExtent") : amended,
     read]
     uint32  VolumeExt;
    [WmiDataId(16),
     Description("Pad3") : amended,
     read]
     uint32  Pad3;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(13),
 EventTypeName("NIC") : amended
]
class SystemConfig_V2_NIC:SystemConfig_V2
{
    [WmiDataId(1),
     Description("PhysicalAddress") : amended,
     format("x"),
     read]
     uint64  PhysicalAddr;
    [WmiDataId(2),
     Description("PhysicalAddressLen") : amended,
     read]
     uint32  PhysicalAddrLen;
    [WmiDataId(3),
     Description("Ipv4Index") : amended,
     read]
     uint32  Ipv4Index;
    [WmiDataId(4),
     Description("Ipv6Index") : amended,
     read]
     uint32  Ipv6Index;
    [WmiDataId(5),
     Description("NIC Description") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string NICDescription;
    [WmiDataId(6),
     Description("IpAddresses") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string IpAddresses;
    [WmiDataId(7),
     Description("DnsServerAddresses") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DnsServerAddresses;

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(14),
 EventTypeName("Video") : amended
]
class SystemConfig_V2_Video:SystemConfig_V2
{
    [WmiDataId(1),
     Description("MemorySize") : amended,
     read]
     uint32  MemorySize;
    [WmiDataId(2),
     Description("XResolution") : amended,
     read]
     uint32  XResolution;
    [WmiDataId(3),
     Description("YResolution") : amended,
     read]
     uint32  YResolution;
    [WmiDataId(4),
     Description("BitsPerPixel") : amended,
     read]
     uint32  BitsPerPixel;
    [WmiDataId(5),
     Description("VRefresh") : amended,
     read]
     uint32  VRefresh;
    [WmiDataId(6),
     Description("ChipType") : amended,
     format("s"),
     read]
     char16  ChipType[256];
    [WmiDataId(7),
     Description("DACType") : amended,
     format("s"),
     read]
     char16  DACType[256];
    [WmiDataId(8),
     Description("AdapterString") : amended,
     format("s"),
     read]
     char16  AdapterString[256];
    [WmiDataId(9),
     Description("BiosString") : amended,
     format("s"),
     read]
     char16  BiosString[256];
    [WmiDataId(10),
     Description("Device Name") : amended,
     format("s"),
     read]
     char16  DeviceId[256];
    [WmiDataId(11),
     Description("StateFlags") : amended,
     format("x"),
     read]
     uint32  StateFlags;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(15),
 EventTypeName("Services") : amended
]
class SystemConfig_V2_Services:SystemConfig_V2
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ServiceState") : amended,
     format("x"),
     read]
     uint32  ServiceState;
    [WmiDataId(3),
     Description("SubProcessTag") : amended,
     format("x"),
     read]
     uint32  SubProcessTag;
    [WmiDataId(4),
     Description("ServiceName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string ServiceName;
    [WmiDataId(5),
     Description("DisplayName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DisplayName;
    [WmiDataId(6),
     Description("ProcessName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string ProcessName;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(16),
 EventTypeName("Power") : amended
]
class SystemConfig_V2_Power:SystemConfig_V2
{
    [WmiDataId(1),
     Description("S1") : amended,
     read]
     uint8  S1;
    [WmiDataId(2),
     Description("S2") : amended,
     read]
     uint8  S2;
    [WmiDataId(3),
     Description("S3") : amended,
     read]
     uint8  S3;
    [WmiDataId(4),
     Description("S4") : amended,
     read]
     uint8  S4;
    [WmiDataId(5),
     Description("S5") : amended,
     read]
     uint8  S5;
    [WmiDataId(6),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad1;
    [WmiDataId(7),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad2;
    [WmiDataId(8),
     Description("Reserved; do not use.") : amended,
     read]
     uint8  Pad3;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(17),
 EventTypeName("Network") : amended
]
class SystemConfig_V2_Network:SystemConfig_V2
{
    [WmiDataId(1),
     Description("TcbTablePartitions") : amended,
     read]
     uint32  TcbTablePartitions;
    [WmiDataId(2),
     Description("MaxHashTableSize") : amended,
     read]
     uint32  MaxHashTableSize;
    [WmiDataId(3),
     Description("MaxUserPort") : amended,
     read]
     uint32  MaxUserPort;
    [WmiDataId(4),
     Description("TcpTimedWaitDelay") : amended,
     read]
     uint32  TcpTimedWaitDelay;

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(21),
 EventTypeName("IRQ") : amended
]
class SystemConfig_V2_IRQ:SystemConfig_V2
{
    [WmiDataId(1),
     Description("IRQAffinity") : amended,
     format("x"),
     read]
     uint64  IRQAffinity;
    [WmiDataId(2),
     Description("IRQNum") : amended,
     read]
     uint32 IRQNum;
    [WmiDataId(3),
     Description("DeviceDescriptionLen") : amended,
     read]
     uint32 DeviceDescriptionLen;
    [WmiDataId(4),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceDescription;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(22),
 EventTypeName("PnP") : amended
]
class SystemConfig_V2_PnP:SystemConfig_V2
{
    [WmiDataId(1),
     Description("IDLength") : amended,
     read]
     uint32  IDLength;
    [WmiDataId(2),
     Description("DescriptionLength") : amended,
     read]
     uint32 DescriptionLength;
    [WmiDataId(3),
     Description("FriendlyNameLength") : amended,
     read]
     uint32 FriendlyNameLength;
    [WmiDataId(4),
     Description("DeviceID") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceID;
    [WmiDataId(5),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceDescription;
    [WmiDataId(6),
     Description("FriendlyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string FriendlyName;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(23),
 EventTypeName("IDEChannel") : amended
]
class SystemConfig_V2_IDEChannel:SystemConfig_V2
{
    [WmiDataId(1),
     Description("TargetId") : amended,
     read]
     uint32  TargetId;
    [WmiDataId(2),
     Description("DeviceType") : amended,
     format("x"),
     read]
     uint32  DeviceType;
    [WmiDataId(3),
     Description("DeviceTimingMode") : amended,
     format("x"),
     read]
     uint32  DeviceTimingMode;
    [WmiDataId(4),
     Description("LocationInformationLen") : amended,
     read]
     uint32  LocationInformationLen;
    [WmiDataId(5),
     Description("LocationInformation") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string LocationInformation;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(25),
 EventTypeName("Platform") : amended
]
class SystemConfig_V2_Platform:SystemConfig_V2
{
    [WmiDataId(1),
     Description("SystemManufacturer") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  SystemManufacturer;
    [WmiDataId(2),
     Description("SystemProductName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  SystemProductName;
    [WmiDataId(3),
     Description("BiosDate") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  BiosDate;
    [WmiDataId(4),
     Description("BiosVersion") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string  BiosVersion;
};

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

};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(21),
 EventTypeName("IRQ") : amended
]
class SystemConfig_IRQ:SystemConfig
{
    [WmiDataId(1),
     Description("IRQAffinity") : amended,
     format("x"),
     read]
     uint64  IRQAffinity;
    [WmiDataId(2),
     Description("IRQGroup") : amended,
     read]
     uint16  IRQGroup;
    [WmiDataId(3),
     Description("Reserved") : amended,
     read]
     uint16  Reserved;
    [WmiDataId(4),
     Description("IRQNum") : amended,
     read]
     uint32 IRQNum;
    [WmiDataId(5),
     Description("DeviceDescriptionLen") : amended,
     read]
     uint32 DeviceDescriptionLen;
    [WmiDataId(6),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceDescription;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(15),
 EventTypeName("Services") : amended
]
class SystemConfig_Services:SystemConfig
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ProcessId;
    [WmiDataId(2),
     Description("ServiceState") : amended,
     format("x"),
     read]
     uint32  ServiceState;
    [WmiDataId(3),
     Description("SubProcessTag") : amended,
     format("x"),
     read]
     uint32  SubProcessTag;
    [WmiDataId(4),
     Description("ServiceName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string ServiceName;
    [WmiDataId(5),
     Description("DisplayName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DisplayName;
    [WmiDataId(6),
     Description("ProcessName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string ProcessName;
    [WmiDataId(7),
     Description("LoadOrderGroup") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string LoadOrderGroup;
    [WmiDataId(8),
     Description("SvchostGroup") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string SvchostGroup;
};

[Dynamic,
 Description("System Configuration") : amended,
 EventType(22),
 EventTypeName("PnP") : amended
]
class SystemConfig_PnP:SystemConfig
{
    [WmiDataId(1),
     Description("IDLength") : amended,
     read]
     uint32  IDLength;
    [WmiDataId(2),
     Description("DescriptionLength") : amended,
     read]
     uint32 DescriptionLength;
    [WmiDataId(3),
     Description("FriendlyNameLength") : amended,
     read]
     uint32 FriendlyNameLength;
    [WmiDataId(4),
     Description("DeviceID") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceID;
    [WmiDataId(5),
     Description("DeviceDescription") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string DeviceDescription;
    [WmiDataId(6),
     Description("FriendlyName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string FriendlyName;
    [WmiDataId(7),
     Description("PdoName") : amended,
     StringTermination("NullTerminated"),
     format("w"),
     read]
     string PdoName;
};

[Dynamic,
 Description("Pool Event") : amended,
 Guid("{0268a8b6-74fd-4302-9dd0-6e8f1795c0cf}"),
 EventVersion(2),
 DisplayName("Pool") : amended
]
class PoolTrace:MSNT_SystemTrace
{

};

[Dynamic,
 Description("Pool Allocation/Free Event") : amended,
 EventType{32, 34},
 EventTypeName{"PoolAllocation", "PoolFree"} : amended
]
class PoolAllocFree:PoolTrace
{
    [WmiDataId(1),
     Description("PoolType"): amended,
     read]
     uint32  Type;
    [WmiDataId(2),
     Description("PoolTag"): amended,
     format("x"),
     read]
     uint32  Tag;
    [WmiDataId(3),
     Description("NumberOfBytes"): amended,
     extension("SizeT"),
     read]
     object NumberOfBytes;
    [WmiDataId(4),
     Description("Entry"): amended,
     pointer,
     read]
     uint32 Entry;
};

[Dynamic,
 Description("Session Pool Allocation/Free Event") : amended,
 EventType{33, 35},
 EventTypeName{"SessionPoolAllocation", "SessionPoolFree"} : amended
]
class SessionPoolAllocFree:PoolTrace
{
    [WmiDataId(1),
     Description("PoolType"): amended,
     read]
     uint32  Type;
    [WmiDataId(2),
     Description("PoolTag"): amended,
     format("x"),
     read]
     uint32  Tag;
    [WmiDataId(3),
     Description("NumberOfBytes"): amended,
     extension("SizeT"),
     read]
     object NumberOfBytes;
    [WmiDataId(4),
     Description("Entry"): amended,
     pointer,
     read]
     uint32 Entry;
    [WmiDataId(5),
     Description("SessionId") : amended,
     read]
     uint32  SessionId;
};


[Dynamic,
 Description("Pool Snapshot Event") : amended,
 EventType{40, 41, 42, 43, 44, 45},
 EventTypeName{"PoolSnapDCStart", "PoolSnapDCEnd", "BigPoolSnapDCStart", "BigPoolSnapDCEnd", "SessionPoolSnapDCStart", "SessionPoolSnapDCEnd"} : amended
]
class PoolSnapshot:PoolTrace
{
};

[Dynamic,
 Description("Thread Pool") : amended,
 Guid("{c861d0e2-a2c1-4d36-9f9c-970bab943a12}")
]
class ThreadPool:EventTrace
{

};

[Dynamic,
 Description("Thread Pool Event") : amended,
 Guid("{c861d0e2-a2c1-4d36-9f9c-970bab943a12}"),
 EventVersion(2),
 DisplayName("ThreadPool") : amended
]
class ThreadPoolTrace_V2:ThreadPool
{

};

[Dynamic,
 Description("Thread Pool Callback Enqueue Start") : amended,
 EventType{32, 34},
 EventTypeName{"CBEnqueue", "CBStart"} : amended
]
class TP_V2_CBEnqueue:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
    [WmiDataId(2),
     Description("TaskId") : amended,
     pointer,
     read]
     uint32  TaskId;
    [WmiDataId(3),
     Description("CallbackFunction") : amended,
     pointer,
     read]
     uint32  CallbackFunction;
    [WmiDataId(4),
     Description("CallbackContext") : amended,
     pointer,
     read]
     uint32  CallbackContext;
    [WmiDataId(5),
     Description("SubProcessTag") : amended,
     pointer,
     read]
     uint32  SubProcessTag;
};

[Dynamic,
 Description("Thread Pool Callback Dequeue Stop") : amended,
 EventType{33, 35},
 EventTypeName{"CBDequeue", "CBStop"} : amended
]
class TP_V2_CBDequeue:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("TaskId") : amended,
     pointer,
     read]
     uint32  TaskId;
};

[Dynamic,
 Description("Thread Pool Callback Cancel") : amended,
 EventType(36),
 EventTypeName("CBCancel") : amended
]
class TP_V2_CBCancel:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("TaskId") : amended,
     pointer,
     read]
     uint32  TaskId;
    [WmiDataId(2),
     Description("CancelCount") : amended,
     read]
     uint32  CancelCount;
};

[Dynamic,
 Description("Thread Pool Pool Create Close") : amended,
 EventType{37, 38},
 EventTypeName{"PoolCreate", "PoolClose"} : amended
]
class TP_V2_PoolCreateClose:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
};

[Dynamic,
 Description("Thread Pool Thread Set") : amended,
 EventType{39, 40},
 EventTypeName{"ThreadMinSet", "ThreadMaxSet"} : amended
]
class TP_V2_ThreadSet:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
    [WmiDataId(2),
     Description("ThreadNum") : amended,
     read]
     uint32  ThreadNum;
};

[Dynamic,
 Description("Thread Pool Worker Thread NUMA Node Switch") : amended,
 EventType(41),
 EventTypeName("WTNodeSwitch") : amended
]
class TP_V2_WTNodeSwitch:ThreadPoolTrace_V2
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
    [WmiDataId(2),
     Description("CurrentNode") : amended,
     read]
     uint32  CurrentNode;
    [WmiDataId(3),
     Description("NextNode") : amended,
     read]
     uint32  NextNode;
    [WmiDataId(4),
     Description("CurrentGroup") : amended,
     read]
     uint16  CurrentGroup;
    [WmiDataId(5),
     Description("NextGroup") : amended,
     read]
     uint16  NextGroup;
    [WmiDataId(6),
     Description("CurrentWorkerCount") : amended,
     read]
     uint32  CurrentWorkerCount;
    [WmiDataId(7),
     Description("NextWorkerCount") : amended,
     read]
     uint32  NextWorkerCount;
};

[Dynamic,
 Description("Thread Pool Event") : amended,
 Guid("{c861d0e2-a2c1-4d36-9f9c-970bab943a12}"),
 EventVersion(3),
 DisplayName("ThreadPool") : amended
]
class ThreadPoolTrace:ThreadPool
{

};

[Dynamic,
 Description("Thread Pool Callback Dequeue Stop") : amended,
 EventType{33, 35},
 EventTypeName{"CBDequeue", "CBStop"} : amended
]
class TPCBDequeue:ThreadPoolTrace
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
    [WmiDataId(2),
     Description("TaskId") : amended,
     pointer,
     read]
     uint32  TaskId;
    [WmiDataId(3),
     Description("CallbackFunction") : amended,
     pointer,
     read]
     uint32  CallbackFunction;
    [WmiDataId(4),
     Description("CallbackContext") : amended,
     pointer,
     read]
     uint32  CallbackContext;
    [WmiDataId(5),
     Description("SubProcessTag") : amended,
     pointer,
     read]
     uint32  SubProcessTag;
};

[Dynamic,
 Description("Thread Pool Callback Cancel") : amended,
 EventType(36),
 EventTypeName("CBCancel") : amended
]
class TPCBCancel:ThreadPoolTrace
{
    [WmiDataId(1),
     Description("PoolId") : amended,
     pointer,
     read]
     uint32  PoolId;
    [WmiDataId(2),
     Description("TaskId") : amended,
     pointer,
     read]
     uint32  TaskId;
    [WmiDataId(3),
     Description("CallbackFunction") : amended,
     pointer,
     read]
     uint32  CallbackFunction;
    [WmiDataId(4),
     Description("CallbackContext") : amended,
     pointer,
     read]
     uint32  CallbackContext;
    [WmiDataId(5),
     Description("SubProcessTag") : amended,
     pointer,
     read]
     uint32  SubProcessTag;
    [WmiDataId(6),
     Description("CancelCount") : amended,
     read]
     uint32  CancelCount;
};

[Dynamic,
 Description("MMCSS") : amended,
 Guid("{f8f10121-b617-4a56-868b-9df1b27fe32c}"),
 DisplayName("MMCSS") : amended
]
class MMCSSTrace:MSNT_SystemTrace
{

};

[Dynamic,
 Description("MMCSS Events") : amended,
 EventType{32, 33, 36, 37},
 EventTypeName{"Start", "Stop", "Sleep", "SleepResp"} : amended
]
class MMCSS_TypeGroup:MMCSSTrace
{

};

[Dynamic,
 Description("MMCSS Events") : amended,
 EventType(34),
 EventTypeName("Scheduler") : amended
]
class MMCSSEvent:MMCSSTrace
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32  ScheduledPID;
    [WmiDataId(2),
     Description("ThreadId") : amended,
     format("x"),
     read]
     uint32  ScheduledTID;
    [WmiDataId(3),
     Description("SchedulingPriority") : amended,
     read]
     uint32  SchedulingPriority;
    [WmiDataId(4),
     Description("TaskIndex") : amended,
     read]
     uint32  TaskIndex;
};

[Dynamic,
 Description("MMCSS Events") : amended,
 EventType(35),
 EventTypeName("Wakeup") : amended
]
class MMCSSWakeup:MMCSSTrace
{
    [WmiDataId(1),
     Description("Reason") : amended,
     format("x"),
     read]
     uint32  Reason;
};

//
// MUI load tracing from ntdll.dll
//
[Dynamic,
 Description("MUI Resource Trace") : amended,
 Guid("{d3de60b2-a663-45d5-9826-a0a5949d2cb0}"),
 locale("MS\\0x409")
]
class MuiTrace:EventTrace
{
};

[Dynamic,
 Description("MUI Resource Trace") : amended,
 Guid("{d3de60b2-a663-45d5-9826-a0a5949d2cb0}"),
 DisplayName("MUIResource") : amended,
 locale("MS\\0x409")
]
class MuiTraceData:MuiTrace
{
};


[Dynamic,
 Description("MUI Resource Access") : amended,
 EventType(0),
 EventTypeName("Access") : amended,
 locale("MS\\0x409")
]
class MuiTraceData_String:MuiTraceData
{
    [WmiDataId(1),
     Description("MuiAccess") : amended,
     format("w"),
     StringTermination("NullTerminated"),
     read]
     string  MuiLoadString;
};

//
// UMS events.
//

[Dynamic,
 Description("UMS Events") : amended,
 Guid("{9aec974b-5b8e-4118-9b92-3186d8002ce5}"),
 EventVersion(2),
 DisplayName("UMS") : amended
]
class UmsEvent:MSNT_SystemTrace
{
};

[Dynamic,
 Description("UMS Directed Switch - Start") : amended,
 EventType(32),
 EventTypeName("DSwitchStart") : amended
]
class UmsDirectedSwitchStart:UmsEvent
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32 ProcessId;
    [WmiDataId(2),
     Description("ScheduledThreadId") : amended,
     format("x"),
     read]
     uint32 ScheduledThreadId;
    [WmiDataId(3),
     Description("PrimaryThreadId") : amended,
     format("x"),
     read]
     uint32 PrimaryThreadId;
    [WmiDataId(4),
     Description("SwitchFlags") : amended,
     format("x"),
     read]
     uint32 SwitchFlags;
};

[Dynamic,
 Description("UMS Directed Switch - End") : amended,
 EventType(33),
 EventTypeName("DSwitchEnd") : amended
]
class UmsDirectedSwitchEnd:UmsEvent
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32 ProcessId;
    [WmiDataId(2),
     Description("ScheduledThreadId") : amended,
     format("x"),
     read]
     uint32 ScheduledThreadId;
    [WmiDataId(3),
     Description("PrimaryThreadId") : amended,
     format("x"),
     read]
     uint32 PrimaryThreadId;
    [WmiDataId(4),
     Description("SwitchFlags") : amended,
     format("x"),
     read]
     uint32 SwitchFlags;
};

[Dynamic,
 Description("UMS Scheduled Thread Park") : amended,
 EventType(34),
 EventTypeName("ScheduledPark") : amended
]
class UmsScheduledPark:UmsEvent
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32 ProcessId;
    [WmiDataId(2),
     Description("ScheduledThreadId") : amended,
     format("x"),
     read]
     uint32 ScheduledThreadId;
    [WmiDataId(3),
     Description("ParkFlags") : amended,
     format("x"),
     read]
     uint32 ParkFlags;
};

[Dynamic,
 Description("UMS Disassociate From Primary") : amended,
 EventType(35),
 EventTypeName("Disassociate") : amended
]
class UmsDisassociate:UmsEvent
{
    [WmiDataId(1),
     Description("ProcessId") : amended,
     format("x"),
     read]
     uint32 ProcessId;
    [WmiDataId(2),
     Description("ScheduledThreadId") : amended,
     format("x"),
     read]
     uint32 ScheduledThreadId;
    [WmiDataId(3),
     Description("PrimaryThreadId") : amended,
     format("x"),
     read]
     uint32 PrimaryThreadId;
    [WmiDataId(4),
     Description("UmsApcControlFlags") : amended,
     format("x"),
     read]
     uint32 UmsApcControlFlags;
    [WmiDataId(5),
     Description("Status") : amended,
     format("x"),
     read]
     uint32 Status;
};

[Dynamic,
 Description("UMS Context Switch") : amended,
 EventType(36),
 EventTypeName("CSwitch") : amended
]
class UmsContextSwitch:UmsEvent
{
    [WmiDataId(1),
     Description("ScheduledThreadId") : amended,
     format("x"),
     read]
     uint32 ScheduledThreadId;
    [WmiDataId(2),
     Description("SwitchCount") : amended,
     read]
     uint32  SwitchCount;
    [WmiDataId(3),
     Description("KernelYieldCount") : amended,
     read]
     uint32 KernelYieldCount;
    [WmiDataId(4),
     Description("MixedYieldCount") : amended,
     read]
     uint32 MixedYieldCount;
    [WmiDataId(5),
     Description("YieldCount") : amended,
     read]
     uint32 YieldCount;
};

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

[WMI,
 guid("{45068237-595D-4C7D-BD80-F84ADC0257F8}")
]
class MSVerifierIrpLogEntry
{
    [WmiDataId(1),
     read,
     DisplayInHex,
     Description("Count")]
    uint32  Count;

    [WmiDataId(2),
     read,
     DisplayInHex,
     Description("Major Function")]
    uint8   Major;

    [WmiDataId(3),
     read,
     DisplayInHex,
     Description("Minor Function")]
    uint8   Minor;

    [WmiDataId(4),
     read,
     DisplayInHex,
     Description("Flags")]
    uint8   Flags;

    [WmiDataId(5),
     read,
     DisplayInHex,
     Description("Control")]
    uint8   Control;

    [WmiDataId(6),
     read,
     DisplayInHex,
     Description("Arg1")]
    uint64   Arg1;

    [WmiDataId(7),
     read,
     DisplayInHex,
     Description("Arg2")]
    uint64   Arg2;

    [WmiDataId(8),
     read,
     DisplayInHex,
     Description("Arg3")]
    uint64   Arg3;

    [WmiDataId(9),
     read,
     DisplayInHex,
     Description("Arg4")]
    uint64   Arg4;
};

[WMI,Dynamic, Provider("WMIProv"),
 Description("Verifier kernel information"),
 guid("{1E2C2980-F7DB-46AA-820E-8734FCC21F4C}"),
 locale("MS\\0x409")
]
class MSVerifierIrpLogInformation
{
    [key, read]
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read,
     Description("DeviceType")
    ] uint32 DeviceType;

    [WmiDataId(2),
     read
    ] uint32 EntryCount;

    [WmiDataId(3),
     WmiSizeIs("EntryCount"),
     read
    ] MSVerifierIrpLogEntry Entries[];
};


[abstract]
class MSMonitorClass
{
};

[WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor brightness parameters"):amended,
 localeid("MS\\0x409"),
 guid("{d43412ac-67f9-4fbb-a081-1752a2c33e84}")]
class WmiMonitorBrightness : MSMonitorClass
{
  [key, read] string InstanceName;
  [read] boolean Active;

  [WmiDataId(1),
   read,
   Description("Current brightness (in percentage of total)"):amended
  ] uint8 CurrentBrightness;

  [WmiDataId(2),
   read,
   Description("Supported brightness levels"):amended
  ] uint32 Levels;

  [WmiDataId(3),
   read,
   Description("Brightness Level - in terms of percentage"):amended,
   WmiSizeIs("Levels")
  ] uint8 Level[];

};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Monitor brightness control API"):amended,
 guid("{479b20b4-5559-46fe-be97-7d222154421f}")]
class WmiMonitorBrightnessMethods : MSMonitorClass
{
  [key, read] string InstanceName;
  [read] boolean Active;

  [WmiMethodId(1),
   Implemented,
   Description("Set current brightness setting"):amended
  ] void WmiSetBrightness([in,
                           Description("Timeout - in seconds"):amended
                          ] uint32 Timeout,
                          [in,
                           Description("Brightness - percentage"):amended
                          ] uint8 Brightness);

  [WmiMethodId(2),
   Implemented,
   Description("Sets the brightness back to the policy setting"):amended
  ] void WmiRevertToPolicyBrightness();

  [WmiMethodId(3),
   Implemented,
   Description("Controls the ambient light sensor brightness state"):amended
  ] void WmiSetALSBrightnessState([in,
                                   Description("ALS brightness state"):amended
                                  ] boolean State);

  [WmiMethodId(4),
   Implemented,
   Description("Sets the ambient light sensor brightness value"):amended
  ] void WmiSetALSBrightness([in,
                              Description("Brightness - percentage"):amended
                             ] uint8 Brightness);
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Monitor brightness change event"),
 guid("{123c80d2-937f-4cfe-80f4-c40d596e48b7}")]
class WmiMonitorBrightnessEvent : WmiEvent
{
  [key, read] string InstanceName;
  [read] boolean Active;

  [WmiDataId(1),
   read,
   Description("Current Monitor Brightness - percentage"):amended
  ] uint8 Brightness;

};

/**********************************/
/* Monitor descriptor data blocks */
/**********************************/


// Deprecated EDID v.1.x standard 128-byte base data block
[WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's raw EDID v.1.x data block") : amended,
 localeid("MS\\0x409"),
 guid("{FAEE1471-5149-4a68-AC2C-BF96EC09F004}")
]
class WmiMonitorRawEEdidV1Block : MSMonitorClass
{
  [key, read] string InstanceName;
  [read] boolean Active;

  [WmiDataId(1), read, Description("Block ID") : amended]
  uint8  Id;

  [
   WmiDataId(2), read, Description("Block type") : amended,
   Values{
           "Uninitialized",
           "Other",
           "EDID base block",
           "EDID map block"
         } : amended
  ]
  uint8  Type;

  [WmiDataId(3), read, Description("Block content") : amended]
  uint8  Content[128];
};


// Exposes the raw content of VESA E-EDID v.1.x standard 128-byte data block.
[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Monitor's raw EDID v.1.x data block accessor"):amended,
 guid("{5341576e-75c4-4aeb-a82b-873cd3c6b384}")]
class WmiMonitorDescriptorMethods : MSMonitorClass
{
  [key, read] string InstanceName;
  [read] boolean Active;

  [WmiMethodId(1),
   Implemented,
   DisplayName("Read EDID v.1.x descriptor block") : amended,
   HeaderName("WmiGetMonitorRawEEdidV1Block"),
   Description("Reads specified EDID v.1.x descriptor block")  : amended
  ]
  void WmiGetMonitorRawEEdidV1Block([in, DisplayName("Block ID") : amended] uint8 BlockId,
                                    [out, DisplayName("Block Type") : amended,
                                     Values{
                                            "Uninitialized",
                                            "Other",
                                            "EDID base block",
                                            "EDID map block"
                                           } : amended
                                    ]
                                     uint8 BlockType,
                                    [out, DisplayName("Block content") : amended] uint8 BlockContent[128]
                                   );
};


// Corresponds to data in the Vendor/Product Identification block of VESA E-EDID standard (section 3.4 of E-EDID v.1.3).
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor ID") : amended,
 localeid("MS\\0x409"),
 guid("{671A8285-4EDB-4cae-99FE-69A15C48C0BC}")
]
class WmiMonitorID : MSMonitorClass
{

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

  [WmiDataId(1), read, Description("Vendor assigned product code ID") : amended]
  // TODO:[mmilirud] Make this variable length.
  uint16 ProductCodeID[16];

  [WmiDataId(2), read, Description("Serial number ID") : amended]
  uint16 SerialNumberID[16];

  [WmiDataId(3), read, Description("Manufacturer name") : amended]
  uint16 ManufacturerName[16];

  [WmiDataId(4), read, Description("Week of manufacture (1..53, 0 = undefined)") : amended]
  uint8 WeekOfManufacture;

  // NOTE: EDID contains (YearOfManufacture-1990). Monitor function driver corrects for that returning a proper year.
  [WmiDataId(5), read, Description("Year of manufacture") : amended]
  uint16 YearOfManufacture;

  [WmiDataId(6), read, Description("Length of user-friendly name") : amended]
  uint16 UserFriendlyNameLength;

  [WmiDataId(7), read, Description("User-friendly name") : amended, WmiSizeIs("UserFriendlyNameLength")]
  uint16 UserFriendlyName[];

};


// Corresponds to data in the Video Input Definition of VESA E-EDID standard (Table 3.11 in section 3.6 of E-EDID v.1.3).
[
 WMI,
 Description("Monitor's supported display features") : amended,
 localeid("MS\\0x409"),
 guid("{9FA9C28B-5E5C-4035-A5F8-67D4554F8D04}")
]
class WmiMonitorSupportedDisplayFeatures
{

   [WmiDataId(1), read, Description("VESA DPMS Standby support") : amended]
   boolean StandbySupported;

   [WmiDataId(2), read, Description("VESA DPMS Suspend support") : amended]
   boolean SuspendSupported;

   // The display consumes much less power when it receives a timing signal that is outside its declared active operating range.
   // The display will revert to normal operation if the timing signal returns to the normal operating range.
   // No sync signals is one example of a timing signal outside normal operating range. No DE signal is another example.
   [WmiDataId(3), read, Description("Active Off/Very Low Power Support") : amended]
   boolean ActiveOffSupported;

   [
    WmiDataId(4), read, Description("Display type") : amended,
    Values{
           "Monochrome/grayscale display",
           "RGB color display",
           "Non-RGB multicolor display"
          } : amended
   ]
   uint8 DisplayType;

   [WmiDataId(5), read, Description("sRGB support") : amended]
   boolean sRGBSupported;

   // If this is set, first detailed timing block contains the preferred timing mode of the monitor
   // Note: Use of preferred timing mode is required by EDID v.1.3 and higher.
   [WmiDataId(6), read, Description("Has a preferred timing mode") : amended]
   boolean HasPreferredTimingMode;

   // If this bit is set to 1, the display supports timings based on the GTF standard using default GTF parameter values.
   [WmiDataId(7), read, Description("GTF support") : amended]
   boolean GTFSupported;

};


// Corresponds to data in the Basic Display Parameters/Features block of VESA E-EDID standard (section 3.6 of E-EDID v.1.3).
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's basic display parameters/features") : amended,
 localeid("MS\\0x409"),
 guid("{9831B7E6-09AC-491f-8D07-3C3D649D8240}")
]
class WmiMonitorBasicDisplayParams : MSMonitorClass
{

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

  [
   WmiDataId(1), read, Description("Video input type") : amended,
   Values{
          "Analog",
          "Digital"
         } : amended
  ]
  uint8  VideoInputType;

  // Maximum image dimensions that can be correctly displayed, as defined by VESA Video Image Area Definition (VIAD) Standard,
  // rounded to the nearest centimeter (cm). These values are intended to be the maximum image size that can be properly displayed
  // over the entire set of supported timing/format combinations. The host system is expected to use this data to get a rough idea
  // of the image size and aspect ratio to allow properly scaled text to be selected.
  // Note: If either (or both) of these fields are zero, then the system shall make no assumption regarding the display size
  // (e.g. a projection display may be of indeterminate size).
  [WmiDataId(2), read, Description("Max horizontal image size (in cm)") : amended]
  uint8  MaxHorizontalImageSize;

  [WmiDataId(3), read, Description("Max vertical image size (in cm)") : amended]
  uint8  MaxVerticalImageSize;

  // TODO:[mmilirud] See if WmiScale(-2) is legal. If so, report gamma rather than 100*Gamma-100.
  [WmiDataId(4), read, WmiScale(-2), Description("Display transfer characteristic (100*Gamma-100)") : amended]
  uint8  DisplayTransferCharacteristic;

  [WmiDataId(5), read, Description("Supported display features") : amended]
  WmiMonitorSupportedDisplayFeatures  SupportedDisplayFeatures;

};

// Returns information regarding how the monitor is connected.
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's basic connection parameters") : amended,
 localeid("MS\\0x409"),
 guid("{2E2D2463-B537-4da7-8EEE-51306F1F482F}")
]
class WmiMonitorConnectionParams : MSMonitorClass
{

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

  [WmiDataId(1), read, Description("Video output technology type") : amended]
  uint32 VideoOutputTechnology;
};


// Corresponds to data in the Video Input Definition of VESA E-EDID standard (Table 3.9 in section 3.6 of E-EDID v.1.3)
// Only available when WmiMonitorBasicDisplayParams.VideoInputType == "Analog".
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's analog video input parameters") : amended,
 localeid("MS\\0x409"),
 guid("{A56DBCF9-C4F0-44a8-9C1B-BB3B3F774B4D}")
]
class WmiMonitorAnalogVideoInputParams : MSMonitorClass
{
  [key, read] string   InstanceName;
  [read]      boolean  Active;

  [
   WmiDataId(1), read, Description("EVC signal level standard") : amended,
   Values{
          "(0.7,0.3)[V]",
          "(0.714,0.286)[V]",
          "(1.0,0.4)[V]",
          "(0.7,0.0)[V]"
         } : amended
  ]
  uint8  SignalLevelStandard;

  [
   WmiDataId(2), read,
   Description("Is setup expected") : amended,
   Values{
          "Monitor expects a blank-to-blank setup or pedestal per appropriate Signal Level Standard",
          "Monitor does NOT expect a blank-to-blank setup or pedestal per appropriate Signal Level Standard"
         } : amended
  ]
  uint8 SetupExpected;

  [
   WmiDataId(3), read,
   Description("Are separate syncs supported") : amended,
   Values{
          "Separate syncs are supported",
          "Separate syncs are NOT supported"
         } : amended
  ]
  uint8  SeparateSyncsSupported;

  [
   WmiDataId(4), read, Description("Is composite sync supported") : amended,
   Values{
          "Composite sync (on Hsync line) is supported",
          "Composite sync (on Hsync line) is NOT supported"
         } : amended
  ]
  uint8  CompositeSyncSupported;

  [
   WmiDataId(5), read, Description("Is sync on green supported") : amended,
   Values{
          "Sync on green video is supported",
          "Sync on green video is NOT supported"
         } : amended
  ]
  uint8  SyncOnGreenVideoSupported;

  [
   WmiDataId(6), read,
   Description("Is Vsync pulse serration required") : amended,
   Values{
          "Serration of the Vsync pulse is required when composite sync or sync-on-green video is used",
          "Serration of the Vsync pulse is NOT required when composite sync or sync-on-green video is used"
         } : amended
  ]
  uint8  SerrationOfVsyncRequired;
};


// Corresponds to data in the Video Input Definition of VESA E-EDID standard (Table 3.9 in section 3.6 of E-EDID v.1.3)
// Only available when WmiMonitorBasicDisplayParams.VideoInputType == "Digital".
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's digital video input parameters") : amended,
 localeid("MS\\0x409"),
 guid("{51565945-498A-4a77-ACC6-151BECC805CA}")
]
class WmiMonitorDigitalVideoInputParams : MSMonitorClass
{

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

  // If set, interface is signal compatible with VESA DFP 1.x TMDS CRGB, 1 pixel/clock, up to 8 bits/color MSB aligned, DE active high.
  [WmiDataId(1), read, Description("VESA DFP 1.x (or compatible)") : amended]
  boolean IsDFP1xCompatible;

};



// The chromaticity and white point values are expressed as fractional numbers using encoding format, accurate to the thousandth place,
// which is 10 bits in length, with the MSB representing 2^-1 and LSB representing 2^-10 coefficients, respectively.
// Precision of the stored values should in the EDID v1.x should be accurate to +/- 0.005 of the actual value.
[
 WMI,
 Description("XYZ CIE coordinates") : amended,
 localeid("MS\\0x409"),
 guid("{01FAF041-842C-4230-A31E-1335428CD8F0}")
]
class WmiMonitorColorXYZinCIE
{

  [WmiDataId(1), WmiScale(-3), read, Description("X") : amended]
  uint16 X;

  [WmiDataId(2), WmiScale(-3), read, Description("Y") : amended]
  uint16 Y;

  // Z can be calculated based on the X and Y values, using the relation ||(X,Y,Z)|| = 1.

};

// Corresponds to data in the Color Characteristics block of VESA E-EDID Standard (see section 3.7 of E-EDID v.1.3)
// Based on CIE publication 15.2 on colorimetry space.
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor color characteristics") : amended,
 localeid("MS\\0x409"),
 guid("{EA324793-51BB-486a-AA9D-0F5552353413}")
]
class WmiMonitorColorCharacteristics : MSMonitorClass
{

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

  [WmiDataId(1), read, Description("Red CIE coordinates") : amended]
  WmiMonitorColorXYZinCIE Red;

  [WmiDataId(2), read,  Description("Blue CIE coordinates") : amended]
  WmiMonitorColorXYZinCIE Blue;

  [WmiDataId(3), read, Description("Green CIE coordinates") : amended]
  WmiMonitorColorXYZinCIE Green;

  // The white point value shall be the default white point (i.e the white point set at power on or on a reset of the display to its default setting).
  // If available, WmiMonitorColorPoint data block can be used to obtain more detailed color characteristics of the monitor.
  [WmiDataId(4), read, Description("Default White CIE coordinates") : amended]
  WmiMonitorColorXYZinCIE DefaultWhite;

};


// Element of the array in WmiMonitorLisetedSupportedSourceModes, used to expose supported video mode's information.
// Contains information that is a superset of the data available from established, standard, and detailed timing blocks.
[
 WMI,
 Description("Video mode descriptor") : amended,
 localeid("MS\\0x409"),
 guid("{4A97ED30-BFAA-491a-9DFD-B43ADEDBF8E3}")
]
class VideoModeDescriptor
{

  [WmiDataId(1), read, Description("Pixel clock rate (Hz)") : amended]
  uint32  PixelClockRate;

  [WmiDataId(2), read, Description("Vertical refresh rate numerator (Hz)") : amended]
  uint32  VerticalRefreshRateNumerator;

  [WmiDataId(3), read, Description("Vertical refresh rate denominator") : amended]
  uint32  VerticalRefreshRateDenominator;

  [WmiDataId(4), read, Description("Horizontal refresh rate numerator (Hz)") : amended]
  uint32  HorizontalRefreshRateNumerator;

  [WmiDataId(5), read, Description("Horizontal refresh rate denominator") : amended]
  uint32  HorizontalRefreshRateDenominator;

  [WmiDataId(6), read, Description("Number of horizontally active pixels") : amended]
  uint16  HorizontalActivePixels;

  [WmiDataId(7), read, Description("Number of vertically active pixels") : amended]
  uint16  VerticalActivePixels;

  [WmiDataId(8), read, Description("Number of horizontally blanking pixels") : amended]
  uint16  HorizontalBlankingPixels;

  [WmiDataId(9), read, Description("Number of vertically blanking pixels") : amended]
  uint16  VerticalBlankingPixels;

  [WmiDataId(10), read, Description("Horizontal sync offset") : amended]
  uint16  HorizontalSyncOffset;

  [WmiDataId(11), read, Description("Vertical sync offset") : amended]
  uint16  VerticalSyncOffset;

  [WmiDataId(12), read, Description("Horizontal sync pulse width") : amended]
  uint16  HorizontalSyncPulseWidth;

  [WmiDataId(13), read, Description("Vertical sync pulse width") : amended]
  uint16  VerticalSyncPulseWidth;

  [WmiDataId(14), read, Description("Horizontal image size (mm)") : amended]
  uint16  HorizontalImageSize;

  [WmiDataId(15), read, Description("Vertical image size (mm)") : amended]
  uint16  VerticalImageSize;

  [WmiDataId(16), read, Description("Horizontal border") : amended]
  uint16  HorizontalBorder;

  [WmiDataId(17), read, Description("Vertical border") : amended]
  uint16  VerticalBorder;

  [WmiDataId(18), read, Description("Is interlaced") : amended]
  boolean  IsInterlaced;

  [
   WmiDataId(19), read, Description("Stereo mode type") : amended,
   Values{
          "No stereo",
          "Field Sequential Stereo with Right Image on Stereo Sync = 1",
          "Field Sequential Stereo with Left Image on Stereo Sync = 1",
          "2-way Interleaved Stereo with Right Image on Even Lines",
          "2-way Interleaved Stereo with Left Image on Even Lines",
          "4-way Interleaved Stereo",
          "Side-by-Side Interleaved Stereo"
         } : amended
  ]
  uint8  StereoModeType;

  [
   WmiDataId(20), read, Description("Signal sync type") : amended,
   Values{
          "Analog Composite",
          "Bipolar Analog Composite",
          "Digital Composite",
          "Digital Separate"
         } : amended
  ]
  uint8  SyncSignalType;

  [
   WmiDataId(21), read, Description("Is serration required") : amended,
   Values{
          "Controller shall supply Hsync during Vsync",
          "Controller shall NOT supply Hsync during Vsync",
          "Not applicable (signal sync type must be [bipolar] analog composite or digital composite)"
         } : amended
  ]
  uint8  IsSerrationRequired;

  [
   WmiDataId(22), read, Description("Is sync on RGB") : amended,
   Values{
          "Sync pulse should appear on all 3 video signal lines",
          "Sync pulse should only appear on the green video signal line",
          "Not applicable (signal sync type must be [bipolar] analog composite)"
         } : amended
  ]
  uint8  IsSyncOnRGB;

  [
   WmiDataId(23), read, Description("Composite polarity type (this is polarity of Hsync pulses outside of Vsync)") : amended,
   Values{
          "Composite polarity is positive",
          "Composite polarity is negative",
          "Not applicable (signal sync type must be digital composite)"
         } : amended
  ]
  uint8  CompositePolarityType;

  [
   WmiDataId(24), read, Description("Vertical polarity type") : amended,
   Values{
          "Vertical polarity is positive",
          "Vertical polarity is negative",
          "Not applicable (signal sync type must be digital separate)"
         } : amended
  ]
  uint8  VerticalPolarityType;

  [
   WmiDataId(25), read, Description("Horizontal polarity type") : amended,
   Values{
          "Horizontal polarity is positive",
          "Horizontal polarity is negative",
          "Not applicable (signal sync type must be digital separate)"
         } : amended
  ]
  uint8  HorizontalPolarityType;

  [
   WmiDataId(26), read, Description("Video standard type") : amended,
   Values{
          "Other",
          "VESA DMT",
          "VESA GTF",
          "VESA CVT",
          "IBM",
          "APPLE",
          "NTSC M",
          "NTSC J",
          "NTSC 433",
          "PAL B",
          "PAL B1",
          "PAL G",
          "PAL H",
          "PAL I",
          "PAL D",
          "PAL N",
          "PAL NC",
          "SECAM B",
          "SECAM D",
          "SECAM G",
          "SECAM H",
          "SECAM K",
          "SECAM K1",
          "SECAM L",
          "SECAM L1",
          "EIA861",
          "EIA861A",
          "EIA861B"
         } : amended
  ]
  uint8  VideoStandardType;

  [
   WmiDataId(27), read, Description("Origin") : amended,
   Values{
          "Uninitialized",
          "Default monitor profile",
          "Monitor's descriptor",
          "Registry override of the monitor descriptor",
          "Registry override of a specific capability"
         } : amended
  ]
  uint8  Origin;

  [
   WmiDataId(28), read, Description("Timing type") : amended,
   Values{
          "Uninitialized",
          "Established",
          "Standard",
          "Extra Standard",
          "Detailed"
         } : amended
  ]
  uint8  TimingType;

};


// Exposes a list of monitor source modes claimed to be supported by the monitor in its monitor descriptor, if any.
// For descriptorless monitors this list of modes is generated based on monitor's type, as specified by the monitor bus driver.
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's listed supported source modes") : amended,
 localeid("MS\\0x409"),
 guid("{6DC76655-063C-4524-A862-B8410C26281B}")
]
class WmiMonitorListedSupportedSourceModes : MSMonitorClass
{

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

  [WmiDataId(1), read, Description("Number of listed supported monitor source modes") : amended]
  uint16  NumOfMonitorSourceModes;

  [WmiDataId(2), read, Description("Preferred monitor source mode index") : amended]
  uint16  PreferredMonitorSourceModeIndex;

  [
   WmiDataId(3), read, Description("Listed supported monitor source modes") : amended,
   WmiSizeIs("NumOfMonitorSourceModes")
  ]
  VideoModeDescriptor  MonitorSourceModes[];

};

// Element of the array in WmiMonitorListedFrequencyRanges, used to expose supported frequency ranges information.
[
 WMI,
 Description("Frequency range descriptor") : amended,
 localeid("MS\\0x409"),
 guid("{F4546078-F3B2-417E-94CD-47EA306C5751}")
]
class FrequencyRangeDescriptor
{
  [
   WmiDataId(1), read, Description("Origin") : amended,
   Values{
          "Uninitialized",
          "Default monitor profile",
          "Monitor's descriptor",
          "Registry override of the monitor descriptor",
          "Registry override of a specific capability"
         } : amended
  ]
  uint8  Origin;

  [WmiDataId(2), read, Description("Minimum VSync numerator (in Hz)") : amended]
  uint32 MinVSyncNumerator;

  [WmiDataId(3), read, Description("Minimum VSync denominator") : amended]
  uint32 MinVSyncDenominator;

  [WmiDataId(4), read, Description("Maximum VSync numerator (in Hz)") : amended]
  uint32 MaxVSyncNumerator;

  [WmiDataId(5), read, Description("Maximum VSync denominator") : amended]
  uint32 MaxVSyncDenominator;

  [WmiDataId(6), read, Description("Minimum HSync numerator (in Hz)") : amended]
  uint32 MinHSyncNumerator;

  [WmiDataId(7), read, Description("Minimum HSync denominator") : amended]
  uint32 MinHSyncDenominator;

  [WmiDataId(8), read, Description("Maximum HSync numerator (in Hz)") : amended]
  uint32 MaxHSyncNumerator;

  [WmiDataId(9), read, Description("Maximum HSync denominator") : amended]
  uint32 MaxHSyncDenominator;

  [WmiDataId(10), read, Description("Constraint type") : amended,
   Values{
          "Uninitialized",
          "Active size",
          "Maximum pixel rate"
         } : amended
  ]
  uint32 ConstraintType;

  [WmiDataId(11), read, Description("Active width (in pixels)") : amended]
  uint32 ActiveWidth;

  [WmiDataId(12), read, Description("Active height (in pixels)") : amended]
  uint32 ActiveHeight;

  [WmiDataId(13), read, Description("Maximum pixel rate (in Hz)") : amended]
  uint32 MaxPixelRate;

};


// Exposes a list of monitor supported frequency ranges claimed to be supported by the monitor in INF and/or EDID, if any.
[
 WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Monitor's listed supported frequency ranges") : amended,
 localeid("MS\\0x409"),
 guid("{E86E9525-65B6-4B85-95C5-00BEACC975ED}")
]
class WmiMonitorListedFrequencyRanges : MSMonitorClass
{

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

  [WmiDataId(1), read, Description("Number of listed supported monitor frequency ranges") : amended]
  uint16  NumOfMonitorFreqRanges;

  [
   WmiDataId(2), read, Description("Listed monitor frequency ranges") : amended,
   WmiSizeIs("NumOfMonitorFreqRanges")
  ]
  FrequencyRangeDescriptor  MonitorFreqRanges[];
};

//
// Definitions for Processor Power Management.
//

[abstract]
class MSKernelPpmClass {
};

//
// Data.
//

[WMI,
 Description("Kernel Processor Performance State"):amended,
 localeid("MS\\0x409"),
 guid("{8c7980e1-f62b-419e-aa82-276c8d064a1f}")]
class KernelPerfState {

    [WmiDataId(1),
     read,
     DisplayName("Processor Speed"):amended,
     Description("Processor Frequency in Megahertz"):amended
    ] uint32 Frequency;

    [WmiDataId(2),
     read,
     DisplayName("Power"):amended,
     Description("Power in milliwatts"):amended
    ] uint32 Power;

    [WmiDataId(3),
     read,
     DisplayName("Performance Percentage"):amended,
     Description("Percentage of Highest Frequency"):amended
    ] uint8 PercentFrequency;

    [WmiDataId(4),
     read,
     DisplayName("IncreaseLevel"):amended,
     Description("IncreaseLevel"):amended
    ] uint8 IncreaseLevel;

    [WmiDataId(5),
     read,
     DisplayName("DecreaseLevel"):amended,
     Description("DecreaseLevel"):amended
    ] uint8 DecreaseLevel;

    [WmiDataId(6),
     read,
     DisplayName("Type"):amended,
     Description("State type: 1 = performance, 2 = throttle"):amended
    ] uint8 Type;

    [WmiDataId(7),
     read,
     DisplayName("IncreaseTime"):amended,
     Description("IncreaseTime"):amended
    ] uint32 IncreaseTime;

    [WmiDataId(8),
     read,
     DisplayName("DecreaseTime"):amended,
     Description("DecreaseTime"):amended
    ] uint32 DecreaseTime;

    [WmiDataId(9),
     read,
     DisplayName("Control"):amended,
     Description("Control value"):amended
    ] uint64 Control;

    [WmiDataId(10),
     read,
     DisplayName("Status"):amended,
     Description("Status value"):amended
    ] uint64 Status;

    [WmiDataId(11),
     read,
     DisplayName("HitCount"):amended,
     Description("Number of times this state has been entered"):amended
    ] uint32 HitCount;

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

    [WmiDataId(13),
     read,
     DisplayName("Reserved2"):amended,
     Description("Reserved"):amended
    ] uint64 Reserved2;

    [WmiDataId(14),
     read,
     DisplayName("Reserved3"):amended,
     Description("Reserved"):amended
    ] uint64 Reserved3;
};


[WMI,
 Dynamic,
 Provider("WmiProv"),
 Description("Kernel Processor Performance States"):amended,
 localeid("MS\\0x409"),
 guid("{5708cc20-7d40-4bf4-b4aa-2b01338d0126}")]
class KernelPerfStates:MSKernelPpmClass {

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

    [WmiDataId(1),
     read,
     DisplayName("Number of Kernel Performance States"):amended,
     Description("Total number of Kernel Performance States"):amended
    ] uint32 Count;

    [WmiDataId(2),
     read,
     DisplayName("MaxFrequency"):amended,
     Description("MaxFrequency"):amended
    ] uint32 MaxFrequency;

    [WmiDataId(3),
     read,
     DisplayName("CurrentState"):amended,
     Description("CurrentState"):amended
    ] uint32 CurrentState;

    [WmiDataId(4),
     read,
     DisplayName("MaxPerfState"):amended,
     Description("Fastest state considering policy restrictions"):amended
    ] uint32 MaxPerfState;

    [WmiDataId(5),
     read,
     DisplayName("MinPerfState"):amended,
     Description("Slowest state considering policy restrictions"):amended
    ] uint32 MinPerfState;

    [WmiDataId(6),
     read,
     DisplayName("LowestPerfState"):amended,
     Description("Slowest performance state disregarding policy restrictions"):amended
    ] uint32 LowestPerfState;

    [WmiDataId(7),
     read,
     DisplayName("ThermalConstraint"):amended,
     Description("Thermal constraint as a percentage"):amended
    ] uint32 ThermalConstraint;

    [WmiDataId(8),
     read,
     DisplayName("BusyAdjThreshold"):amended,
     Description("BusyAdjThreshold"):amended
    ] uint8 BusyAdjThreshold;

    [WmiDataId(9),
     read,
     DisplayName("PolicyType"):amended,
     Description("Processor domain coordination"):amended
    ] uint8 PolicyType;

    [WmiDataId(10),
     read,
     DisplayName("Type"):amended,
     Description("Type"):amended
    ] uint8 Type;

    [WmiDataId(11),
     read,
     DisplayName("Reserved"):amended,
     Description("Reserved"):amended
    ] uint8 Reserved;

    [WmiDataId(12),
     read,
     DisplayName("TimerInterval"):amended,
     Description("Timer interval in milliseconds"):amended
    ] uint32 TimerInterval;

    [WmiDataId(13),
     read,
     DisplayName("TargetProcessors"):amended,
     Description("Processor domain affinity"):amended
    ] uint64 TargetProcessors;

    [WmiDataId(14),
     read,
     DisplayName("PState Handler"):amended,
     Description("PState Handler"):amended
    ] uint32 PStateHandler;

    [WmiDataId(15),
     read,
     DisplayName("PState Context"):amended,
     Description("PState Context"):amended
    ] uint32 PStateContext;

    [WmiDataId(16),
     read,
     DisplayName("TState Handler"):amended,
     Description("TState Handler"):amended
    ] uint32 TStateHandler;

    [WmiDataId(17),
     read,
     DisplayName("TState Context"):amended,
     Description("TState Context"):amended
    ] uint32 TStateContext;

    [WmiDataId(18),
     read,
     DisplayName("FeedbackHandler"):amended,
     Description("FeedbackHandler"):amended
    ] uint32 FeedbackHandler;

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

    [WmiDataId(20),
     read,
     DisplayName("Reserved2"):amended,
     Description("Reserved"):amended
    ] uint64 Reserved2;

    [WmiDataId(21),
     read,
     DisplayName("Performance States"):amended,
     Description("Array of Performance States"):amended,
     WmiSizeIs("Count")
    ] KernelPerfState State[];
};

[WMI,
 Description("Kernel Idle State"):amended,
 localeid("MS\\0x409"),
 guid("{46bdcf4a-e076-4550-82b2-9f32eded3e7f}")]
class KernelIdleState {

    [WmiDataId(1),
     read,
     DisplayName("Latency"):amended,
     Description("Worst case transition latency to enter and exit the idle state [QueryPerformanceCounter units]"):amended
    ] uint32 Latency;

    [WmiDataId(2),
     read,
     DisplayName("Power"):amended,
     Description("Average power consumption in the idle state [milliwatts]"):amended
    ] uint32 Power;

    [WmiDataId(3),
     read,
     DisplayName("TimeCheck"):amended,
     Description("TimeCheck policy [QueryPerformanceCounter units]"):amended
    ] uint32 TimeCheck;

    [WmiDataId(4),
     read,
     DisplayName("PromotePercent"):amended,
     Description("PromotePercent policy"):amended
    ] uint8 PromotePercent;

    [WmiDataId(5),
     read,
     DisplayName("DemotePercent"):amended,
     Description("DemotePercent policy"):amended
    ] uint8 DemotePercent;

    [WmiDataId(6),
     read,
     DisplayName("StateType"):amended,
     Description("Idle state type per ACPI {1=C1, 2=C2, 3=C3, 4=C4, ...}"):amended
    ] uint8 StateType;

    [WmiDataId(7),
     read,
     DisplayName("Reserved"):amended,
     Description("Reserved"):amended
    ] uint8 Reserved;

    [WmiDataId(8),
     read,
     DisplayName("StateFlags"):amended,
     Description("StateFlags"):amended      // IDLE_STATE_FLAGS_*
    ] uint32 StateFlags;
  
    [WmiDataId(9),
     read,
     DisplayName("Context"):amended,
     Description("IdleHandler context present"):amended
    ] uint32 Context;
  
    [WmiDataId(10),
     read,
     DisplayName("IdleHandler"):amended,
     Description("IdleHandler present"):amended
    ] uint32 IdleHandler;

    [WmiDataId(11),
     read,
     DisplayName("Reserved1"):amended,
     Description("Reserved"):amended
    ] uint32 Reserved1;
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Description("Kernel Idle States"):amended,
 localeid("MS\\0x409"),
 guid("{ba138e10-e250-4ad7-8616-cf1a7ad410e7}")]
class KernelIdleStates:MSKernelPpmClass {

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

    [WmiDataId(1),
     read,
     DisplayName("Type"):amended,
     Description("Type"):amended            // IDLE_STATES_LINEAR, etc
    ] uint32 Type;

    [WmiDataId(2),
     read,
     DisplayName("Number of Kernel Idle States"):amended,
     Description("Total number of Kernel Idle States"):amended
    ] uint32 Count;

    [WmiDataId(3),
     read,
     DisplayName("TargetState"):amended,
     Description("Current target idle state"):amended
    ] uint32 TargetState;

    [WmiDataId(4),
     read,
     DisplayName("TargetState"):amended,
     Description("Previous target idle state"):amended
    ] uint32 OldState;
  
    [WmiDataId(5),
     read,
     DisplayName("TargetProcessors"):amended,
     Description("TargetProcessors"):amended
    ] uint64 TargetProcessors;
  
    [WmiDataId(6),
     read,
     DisplayName("Idle States"):amended,
     Description("Array of Idle States"):amended,
     WmiSizeIs("Count")
    ] KernelIdleState State[];
};

//
// Events.
//

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Perf State Transition Event"),
 guid("{A5B32DDD-7F39-4abc-B892-900E43B59EBB}")]
class KernelPerfStateChange:WmiEvent {

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

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

    [WmiDataId(2),
     read,
     DisplayName("Status"):amended,
     Description("Status"):amended
    ] uint32 Status;

    [WmiDataId(3),
     read,
     DisplayName("Latency"):amended,
     Description("Latency"):amended
    ] uint32 Latency;

    [WmiDataId(4),
     read,
     DisplayName("Cpu Speed"):amended,
     Description("Cpu Speed"):amended
    ] uint32 Speed;
    
    [WmiDataId(5),
     read,
     DisplayName("Processor"):amended,
     Description("Processor"):amended
    ] uint32 Processor;
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Perf State Domain Transition Event"),
 guid("{995e6b7f-d653-497a-b978-36a30c29bf01}")]
class KernelPerfStateDomainChange:WmiEvent {

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

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

    [WmiDataId(2),
     read,
     DisplayName("Latency"):amended,
     Description("Latency"):amended
    ] uint32 Latency;

    [WmiDataId(3),
     read,
     DisplayName("Cpu Speed"):amended,
     Description("Cpu Speed"):amended
    ] uint32 Speed;
    
    [WmiDataId(4),
     read,
     DisplayName("Processors"):amended,
     Description("Mask of processors in the same domain"):amended
    ] uint64 Processors;
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Idle State Change Event"),
 guid("{4838fe4f-f71c-4e51-9ecc-8430a7ac4c6c}")]
class KernelIdleStateChange:WmiEvent {

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

    [WmiDataId(1),
     read,
     DisplayName("NewState"):amended,
     Description("New Target Idle State"):amended
    ] uint32 NewState;

    [WmiDataId(2),
     read,
     DisplayName("OldState"):amended,
     Description("Old Target Idle State"):amended
    ] uint32 OldState;

    [WmiDataId(3),
     read,
     DisplayName("TargetProcessors"):amended,
     Description("TargetProcessors"):amended
    ] uint64 Processors;
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Thermal Event"),
 guid("{a852c2c8-1a4c-423b-8c2c-f30d82931a88}")]
class KernelThermalConstraintChange:WmiEvent {

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

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

    [WmiDataId(2),
     read,
     DisplayName("TargetProcessors"):amended,
     Description("TargetProcessors"):amended
    ] uint64 Processors;
};

[WMI,
 localeid("MS\\0x409"),
 Description("Kernel Idle State Accounting"):amended,
 guid("{5280028a-c24f-43ec-b27d-a960a70e319a}")]
class IdleStateAccounting {

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

    [WmiDataId(2),
     read,
     DisplayName("FailedTransitions"):amended,
     Description("FailedTransitions"):amended
    ] uint32 FailedTransitions;

    [WmiDataId(3),
     read,
     DisplayName("InvalidBucketIndex"):amended,
     Description("InvalidBucketIndex"):amended
    ] uint32 InvalidBucketIndex;
    
    [WmiDataId(4),
     read,
     DisplayName("TotalTime"):amended,
     Description("TotalTime"):amended
    ] uint64 TotalTime;

    [WmiDataId(5),
     read,
     DisplayName("IdleTimeBuckets"):amended,
     Description("IdleTimeBuckets"):amended
    ] uint32 IdleTimeBuckets[6];
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Idle Accounting"):amended,
 guid("{e2a26f78-ae07-4ee0-a30f-ce354f5a94cd}")]
class IdleAccounting:WmiEvent {

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

    [WmiDataId(1),
     read,
     DisplayName("Number of Idle States"):amended,
     Description("Total number of Kernel Idle States"):amended
    ] uint32 StateCount;

    [WmiDataId(2),
     read,
     DisplayName("TotalTransitions"):amended,
     Description("TotalTransitions"):amended
    ] uint32 TotalTransitions;

    [WmiDataId(3),
     read,
     DisplayName("ResetCount"):amended,
     Description("ResetCount"):amended
    ] uint32 ResetCount;

    [WmiDataId(4),
     read,
     DisplayName("StartTime"):amended,
     Description("StartTime"):amended
    ] uint64 StartTime;

    [WmiDataId(5),
     read,
     DisplayName("Idle States Accounting"):amended,
     Description("Accounting Data for Kernel Idle States"):amended,
     WmiSizeIs("StateCount")
    ] IdleStateAccounting State[];
};

[WMI,
 localeid("MS\\0x409"),
 Description("Kernel Idle State Bucket Extended"):amended,
 guid("{e53e0a7d-36f0-4a77-879e-9c6b5e4a8554}")]
class IdleStateBucketEx {

    [WmiDataId(1),
     read,
     DisplayName("TotalTimeUs"):amended,
     Description("TotalTimeUs"):amended
    ] uint64 TotalTimeUs;
    
    [WmiDataId(2),
     read,
     DisplayName("MinTimeUs"):amended,
     Description("MinTimeUs"):amended
    ] uint32 MinTimeUs;
    
    [WmiDataId(3),
     read,
     DisplayName("MaxTimeUs"):amended,
     Description("MaxTimeUs"):amended
    ] uint32 MaxTimeUs;
    
    [WmiDataId(4),
     read,
     DisplayName("Count"):amended,
     Description("Count"):amended
    ] uint32 Count;
};

[WMI,
 localeid("MS\\0x409"),
 Description("Kernel Idle State Accounting"):amended,
 guid("{3e0d7b2c-401b-480f-8303-d0c20ea1a7d8}")]
class IdleStateAccountingEx {

    [WmiDataId(1),
     read,
     DisplayName("TotalTime"):amended,
     Description("TotalTime"):amended
    ] uint64 TotalTime;

    [WmiDataId(2),
     read,
     DisplayName("IdleTransitions"):amended,
     Description("IdleTransitions"):amended
    ] uint32 IdleTransitions;

    [WmiDataId(3),
     read,
     DisplayName("FailedTransitions"):amended,
     Description("FailedTransitions"):amended
    ] uint32 FailedTransitions;
    
    [WmiDataId(4),
     read,
     DisplayName("InvalidBucketIndex"):amended,
     Description("InvalidBucketIndex"):amended
    ] uint32 InvalidBucketIndex;
    
    [WmiDataId(5),
     read,
     DisplayName("MinTimeUs"):amended,
     Description("MinTimeUs"):amended
    ] uint32 MinTimeUs;
    
    [WmiDataId(6),
     read,
     DisplayName("MaxTimeUs"):amended,
     Description("MaxTimeUs"):amended
    ] uint32 MaxTimeUs;
    
    [WmiDataId(7),
     read,
     DisplayName("IdleTimeBuckets"):amended,
     Description("IdleTimeBuckets"):amended
    ] IdleStateBucketEx IdleTimeBuckets[16];
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Idle Accounting"):amended,
 guid("{d67abd39-81f8-4a5e-8152-72e31ec912ee}")]
class IdleAccountingEx:WmiEvent {

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

    [WmiDataId(1),
     read,
     DisplayName("Number of Idle States"):amended,
     Description("Total number of Kernel Idle States"):amended
    ] uint32 StateCount;

    [WmiDataId(2),
     read,
     DisplayName("TotalTransitions"):amended,
     Description("TotalTransitions"):amended
    ] uint32 TotalTransitions;

    [WmiDataId(3),
     read,
     DisplayName("ResetCount"):amended,
     Description("ResetCount"):amended
    ] uint32 ResetCount;

    [WmiDataId(4),
     read,
     DisplayName("StartTime"):amended,
     Description("StartTime"):amended
    ] uint64 StartTime;

    [WmiDataId(5),
     read,
     DisplayName("Idle States Accounting"):amended,
     Description("Accounting Data for Kernel Idle States"):amended,
     WmiSizeIs("StateCount")
    ] IdleStateAccountingEx State[];
};

[WMI,
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Kernel Thermal Policy Event"),
 guid("{aca5a8f7-96ca-4397-bade-43be2f577d51}")]
class KernelThermalPolicyChange:WmiEvent {

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

    [WmiDataId(1),
     read,
     DisplayName("Cooling Policy"):amended,
     Description("Current ACPI Cooling Mode"):amended
    ] uint8 CoolingMode;

    [WmiDataId(2),
     read,
     DisplayName("Processors"):amended,
     Description("Processors"):amended
    ] uint64 Processors;
};

//
// Define schema for performance counters to be displayed by perfmon
//
// All perf counter classes must derived from Win32_PerfRawData and
// have the hiperf qualifier.
//
// Each property within the class must have the following qualifiers:
//
//        CounterType - This defines the type of counter. See winperf.h
//                      for more information on what values to place in this
//                      qualifier.
//
//        PerfDetail  - The amount of detail supplied by the counter.
//            PERF_DETAIL_NOVICE          100 // The uninformed can understand it
//            PERF_DETAIL_ADVANCED        200 // For the advanced user
//            PERF_DETAIL_EXPERT          300 // For the expert user
//            PERF_DETAIL_WIZARD          400 // For the system designer
//
//        DefaultScale - Power if 10 by which to scale chart line if
//                       vertical axis is 100. 0 ==> 1, 1 ==> 10,
//                       -1 ==> 1/10. Used for purposes display only.
//
// Also property may have the following optional qualifiers
//
//        PerfDefault  - Denotes the property that is the default counter
//                       as displayed by the Sysmon list box. Only one
//                       property may have this qualifier.
//
//        Costly       - Indicates that the value for the property may
//                       be costly to obtain
//
//
// Only int32, uint32, int64 and uint64 properties will be displayed in sysmon
//
// All performance counter classes should be localizable, which means that
// they should include ammended DisplayName and Description class and property
// qualifiers.
//

[WMI,
 Dynamic,
 Provider("WMIProv"),
 Description("Processor Performance Information"):amended,
 DisplayName("Processor Performance"):amended,
 localeid("MS\\0x409"),
 guid("{7FD18652-0CFE-40d2-B0A1-0B066A87759E}"),
 PerfDetail(100),
 HiPerf]
class ProcessorPerformance:Win32_PerfRawData {

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

    [WmiDataId(1),
     read,
     DisplayName("Processor Frequency"):amended,
     Description("Current Processor Frequency in megahertz"):amended,
     PerfDefault,
     CounterType(0x00010000),
     DefaultScale(0),
     PerfDetail(100)
    ] uint32 frequency;

    [WmiDataId(2),
     read,
     DisplayName("Processor State Flags"):amended,
     Description("Processor State Flags"):amended,
     CounterType(0x00000000),
     DefaultScale(0),
     PerfDetail(100)
    ] uint32 power;

    [WmiDataId(3),
     read,
     DisplayName("% of Maximum Frequency"):amended,
     Description("Percentage of maximum processor frequency"):amended,
     CounterType(0x00010000),
     DefaultScale(0),
     PerfDetail(100)
    ] uint32 percentage;
};