/*++

Copyright (c) 1999  Microsoft Corporation

Module Name:

   test.mof

Abstract:

	Test mof used to validate the BMOF Loc parser. It includes the 
following:


* Namespace changes
  - at top of file
  - in middle of file
* Classflag changes
* InstanceFlag changes
* Instance definitions
  - All Data Types for properties
  - Class qualifiers have all types
  - Class has no qualifiers
  - Property qualifiers of all types
  - Property with no qualifiers
  - Embedded classes
  - arrays of embedded classes
  - embedded classes within embedded classes
* Class definitions
  - All Data Types for properties
  - Class qualifiers have all types
  - Class has no qualifiers
  - Property qualifiers of all types
  - Property with no qualifiers
  - Derived classes
* Methods
  - All data types as return type
  - All data types as parameters
  - void return type
  - void parameters
  - all qualifier types on parameters
  - no qualifier on parameters
  - no qualifier on method
  - only IN params
  - only OUT params
  - only IN params & void return
  - only OUT & void return
  - only IN & non void return
* Qualifier flavors
* include pragma
* aliases

--*/


#pragma namespace("\\\\.\\root\\testit")
#pragma classflags("forceupdate", "updateonly")

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
class Embded
{
[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    boolean Xboolean;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint8 Xuint8;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint16 Xuint16;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint32 Xuint32;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint64 Xuint64;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint8 Xint8;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint16 Xint16;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint32 Xint32;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint64 Xint64;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    datetime Xdatetime;

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    string Xstring;

};

class YY as $MyYY
{
[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    Embed XX;
};

class noqual
{
    
    boolean Xboolean;

    uint8 Xuint8;

    uint16 Xuint16;

    uint32 Xuint32;

    uint64 Xuint64;

    sint8 Xint8;

    sint16 Xint16;

    sint32 Xint32;

    sint64 Xint64;

    datetime Xdatetime;

    string Xstring;

    YY XEmbed;
};

instance of Embed
{
     Xboolean = "TRUE";

     Xuint8 = 1;

     Xuint16 = 2;

    Xuint32 = 3;

    Xuint64 = 4;

    Xint8 = 5;

     Xint16 = 6;

     Xint32 = 7;

     Xint64 = 8;

     Xstring = "XYZZY";
};

#pragma instanceflags("updateonly")

class small
{
    string str;
    uint8 ii;
};

class esmall
{
    [key] string xx;
    small Smally;
};

#pragma instanceflags("createonly")

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
instance of esmall
{
    xx = "A";
    Smally = instance of small { xx = "xxxx"; ii = 33; };	
};


[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
instance of esmall
{
    xx = "B";
[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    Smally = instance of small { xx = "yyyy"; ii = 99; };	
};

class xxxxx
{
   [key] string sss;
   esmall eee;
};

instance of xxxxx
{
  sss = "foo";
  eee = instance of esmall { 
                             xx = "C"; 
                             Smally = instance of small { 
                                                         xx = "rr"; 
                                                         ii = 22;};
                           };
};

class earr
{
    uint8 arr[];
};

instance of earr
{
    arr = { 1,2,3,4,5 };
};

class Caller
{
    boolean Xboolean();

    uint8 Xuint8();

    uint16 Xuint16();

    uint32 Xuint32();

    uint64 Xuint64();

    sint8 Xint8();

    sint16 Xint16();

    sint32 Xint32();

    sint64 Xint64();

    datetime Xdatetime();

    string Xstring();

    YY XEmbedX();

    void Nothing();

    void lots([in, out] boolean Xboolean,
	      [in, out] uint8 Xuint8,
	      [in, out] uint16 Xuint16,
	      [in, out] uint32 Xuint32,
	      [in, out] uint64 Xuint64,
	      [in, out] sint8 Xint8,
	      [in, out] sint16 Xint16,
	      [in, out] sint32 Xint32,
	      [in, out] sint64 Xint64,
	      [in, out] datetime Xdatetime,
	      [in, out] string Xstring,
	      [in, out] YY XEmbedX);

};

class Caller2
{
[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    boolean Xboolean([in] uint8 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint8 Xuint8([in] uint16 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint16 Xuint16([in] uint32 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint32 Xuint32([in] uint64 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    uint64 Xuint64([in] sint8 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint8 Xint8([in] sint16 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint16 Xint16([in] sint32 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint32 Xint32([in] sint64 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    sint64 Xint64([in] datetime i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    datetime Xdatetime([in] string i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    string Xstring([in] YY i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    YY XEmbedX([in] boolean i);


    boolean XbooleanX([out] uint8 i);

    uint8 Xuint8X([out] uint16 i);

    uint16 Xuint16X([out] uint32 i);

    uint32 Xuint32X([out] uint64 i);

    uint64 Xuint64X([out] sint8 i);

    sint8 Xint8X([out] sint16 i);

    sint16 Xint16X([out] sint32 i);

    sint32 Xint32X([out] sint64 i);

    sint64 Xint64X([out] datetime i);

    datetime XdatetimeX([out] string i);

    string XstringX([out] YY i);

    YY XEmbedXX([out] boolean i);

    
};

class caller4
{
[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xboolean([in] uint8 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xuint8([in] uint16 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xuint16([in] uint32 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xuint32([in] uint64 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xuint64([in] sint8 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xint8([in] sint16 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xint16([in] sint32 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xint32([in] sint64 i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xint64([in] datetime i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xdatetime([in] string i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void Xstring([in] YY i);

[qualbool, qualbool2(FALSE), 
 qualarrstr { "string1", "string2", "string3" },
 qualarrint { 1, 2, 3 }
]
    void XEmbedX([in] boolean i);


    void XbooleanX([out] uint8 i);

    void Xuint8X([out] uint16 i);

    void Xuint16X([out] uint32 i);

    void Xuint32X([out] uint64 i);

    void Xuint64X([out] sint8 i);

    void Xint8X([out] sint16 i);

    void Xint16X([out] sint32 i);

    void Xint32X([out] sint64 i);

    void Xint64X([out] datetime i);

    void XdatetimeX([out] string i);

    void XstringX([out] YY i);

    void XEmbedXX([out] boolean i);


};

#pragma namespace("subspace")

//
// Define EC1 and EC2 as embedded classes. Embedded classes are structures
// that are used within other classes.
//
[WMI,
 Locale("MS\\0x409"),
 HeaderName("EC1"),
 Description("Description of embedeed class 1"),
 guid("{A1C15015-B069-11d1-9290-00A0C9062910}")]
class Vendor_EC1
{
    [WmiDataId(1),
     read, write,
     Description("boolean data")
    ] boolean Xboolean;

    [WmiDataId(2),
     read, write,
     Description("unsigned character data")
    ] uint8 Xuint8;

    [WmiDataId(3),
     read, write,
     Description("unsigned short data")
    ] uint16 Xuint16;

    [WmiDataId(4),
     read, write,
     Description("unsigned long data")
    ] uint32 Xuint32;

    [WmiDataId(5),
     read, write,
     Description("unsigned long long data")
    ] uint64 Xuint64;

    [WmiDataId(6),
     read, write,
     Description("signed byte data")
    ] sint8 Xint8;

    [WmiDataId(7),
     read, write,
     Description("singed short data")
    ] sint16 Xint16;

    [WmiDataId(8),
     read, write,
     Description("singed long data")
    ] sint32 Xint32;

    [WmiDataId(9),
     read, write,
     Description("signed long long data")
    ] sint64 Xint64;

    [WmiDataId(10),
     read, write,
     Description("absolute or relative date and time")
    ] datetime Xdatetime;

};

[WMI,
 Locale("MS\\0x409"),
 HeaderName("EC2"),
 Description("Description of embedeed class 2"),
 guid("{A1C15016-B069-11d1-9290-00A0C9062910}")]
class Vendor_EC2
{
    [WmiDataId(1),
     read, write,
     Description("Fixed length array of 8 booleans")
    ] boolean Xboolean[8];

    [WmiDataId(2),
     read, write,
     Description("Fixed length array of 8 unsigned characters")
    ] uint8 Xuint8[8];

    [WmiDataId(3),
     read, write,
     Description("Fixed length array of 4 unsigned shorts")
    ] uint16 Xuint16[4];

    [WmiDataId(4),
     read, write,
     Description("Fixed length array of 2 usingned long")
    ] uint32 Xuint32[2];

    [WmiDataId(5),
     read, write,
     Description("Unsigned long long")
    ] uint64 Xuint64;

    [WmiDataId(6),
     read, write,
     Description("Fixed length array of 8 signed characters")
    ] sint8 Xint8[8];

    [WmiDataId(7),
     read, write,
     Description("Fixed length array of 4 signed short")
    ] sint16 Xint16[4];

    [WmiDataId(8),
     read, write,
     Description("Fixed length array of 2 signed long")
    ] sint32 Xint32[2];

    [WmiDataId(9),
     read, write,
     Description("Signed long long")
    ] sint64 Xint64;

    [WmiDataId(10),
     read, write,
     Description("absolute or relative date and time")
    ] datetime Xdatetime;
};

#pragma classflags("createonly")

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of sample class 1"),
 Locale("MS\\0x409"),
 guid("{15D851F1-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass1
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("boolean data")
    ] boolean Xboolean;

    [WmiDataId(2),
     read, write,
     Description("unsigned character data")
    ] uint8 Xuint8;

    [WmiDataId(3),
     read, write,
     Description("unsigned short data")
    ] uint16 Xuint16;

    [WmiDataId(4),
     read, write,
     Description("unsigned long data")
    ] uint32 Xuint32;

    [WmiDataId(5),
     read, write,
     Description("unsigned long long data")
    ] uint64 Xuint64;

    [WmiDataId(6),
     read, write,
     Description("signed byte data")
    ] sint8 Xint8;

    [WmiDataId(7),
     read, write,
     Description("singed short data")
    ] sint16 Xint16;

    [WmiDataId(8),
     read, write,
     Description("singed long data")
    ] sint32 Xint32;

    [WmiDataId(9),
     read, write,
     Description("signed long long data")
    ] sint64 Xint64;

    [WmiDataId(10),
     read, write,
     Description("absolute or relative date and time")
    ] datetime Xdatetime;
    
};
[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 2"),
 Locale("MS\\0x409"),
 guid("{15D851F2-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass2
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("Embedded class data")
    ] Vendor_EC1 EmbeddedClass1;
    
};

#pragma classflags("forceupdate")

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 3"),
 Locale("MS\\0x409"),
 guid("{15D851F3-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass3
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("FIxed length array of 4 embedded classes")
    ] Vendor_EC1 EmbeddedClass1[4];
    
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 4"),
 Locale("MS\\0x409"),
 guid("{15D851F4-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass4
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("Number of elements in array")
    ] uint32 Count;
    [WmiDataId(2),
     read, write,
     Description("Variable length array of embedded classes. Count specifies the number of elements in the array"),
     WmiSizeIs("Count")] Vendor_EC1 EmbeddedClass1[];
    
};

#pragma classflags("safeupdate")

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 5"),
 Locale("MS\\0x409"),
 guid("{15D851F5-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass5
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("Embedded class data")
    ] Vendor_EC2 EmbeddedClass2;
    
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 6"),
 Locale("MS\\0x409"),
 guid("{15D851F6-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass6
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("Fixed length array of 4 embedded classes")
    ] Vendor_EC2 EmbeddedClass2[4];
    
};

#pragma classflags("updateonly")

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("Description of Sample Class 7"),
 Locale("MS\\0x409"),
 guid("{15D851F7-6539-11d1-A529-00A0C9062910}")]
class Vendor_SampleClass7
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     read, write,
     Description("Number of elements in array")
    ] uint32 Count;
    [WmiDataId(2),
     read, write,
     Description("Variable length array of embedded classes. Count specifies the number of elements in the array"),
     WmiSizeIs("Count")] Vendor_EC2 EmbeddedClass2[];
    
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Methods that can get and set data"),
 guid("{15D851F8-6539-11d1-A529-00A0C9062910}")]
class Vendor_GetSetData
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [Implemented,
     Description("Change the contents of EC1"),
     WmiMethodId(1)] void SetEC1([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                 ] uint32 BlockIndex,
                                 [in] uint32 pad,
                                 [in] boolean Xboolean,
                                 [in] uint8 Xuint8,
                                 [in] uint16 Xuint16,
                                 [in] uint32 Xuint32,
                                 [in] uint64 Xuint64,
                                 [in] sint8 Xint8,
                                 [in] sint16 Xint16,
                                 [in] sint32 Xint32,
                                 [in] sint64 Xint64,
                                 [in] datetime Xdatetime);
                           
    [Implemented,
     Description("Change the contents of EC2"),
     WmiMethodId(2)] void SetEC2([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                 ] uint32 BlockIndex,
                                 [in] uint32 pad,
                                 [in] boolean Xboolean[8],
                                 [in] uint8 Xuint8[8],
                                 [in] uint16 Xuint16[4],
                                 [in] uint32 Xuint32[2],
                                 [in] uint64 Xuint64,
                                 [in] sint8 Xint8[8],
                                 [in] sint16 Xint16[4],
                                 [in] sint32 Xint32[2],
                                 [in] sint64 Xint64,
                                 [in] datetime Xdatetime);
                           
    [Implemented,
     Description("Get the contents of EC1"),
     WmiMethodId(3)] void GetEC1([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                 ] uint32 BlockIndex,
                                 [out] boolean Xboolean,
                                 [out] uint8 Xuint8,
                                 [out] uint16 Xuint16,
                                 [out] uint32 Xuint32,
                                 [out] uint64 Xuint64,
                                 [out] sint8 Xint8,
                                 [out] sint16 Xint16,
                                 [out] sint32 Xint32,
                                 [out] sint64 Xint64,
                                 [out] datetime Xdatetime);
                           
    [Implemented,
     Description("Get the contents of EC2"),
     WmiMethodId(4)] void GetEC2([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                 ] uint32 BlockIndex,
                                 [out] boolean Xboolean[8],
                                 [out] uint8 Xuint8[8],
                                 [out] uint16 Xuint16[4],
                                 [out] uint32 Xuint32[2],
                                 [out] uint64 Xuint64,
                                 [out] sint8 Xint8[8],
                                 [out] sint16 Xint16[4],
                                 [out] sint32 Xint32[2],
                                 [out] sint64 Xint64,
                                 [out] datetime Xdatetime);
                           
    [Implemented,
     Description("Cause driver to update its registration to remove Vendor_SampleClass7"),
     WmiMethodId(5)] void DisableSampleClass7();

    [Implemented,
     Description("Cause driver to update its registration to include Vendor_SampleClass7"),
     WmiMethodId(6)] void EnableSampleClass7();

    [Implemented, 
     Description("Change the contents of Ec1"),
     WmiMethodId(7)] void SetEC1AsEc([in,
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                     ] uint32 BlockIndex,
                                     [in] Vendor_EC1 Ec1
                                    );
                           
    [Implemented,
     Description("Change the contents of Ec2"),
     WmiMethodId(8)] void SetEC2AsEc([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                     ] uint32 BlockIndex,
                                     [in] Vendor_EC2 Ec2);
                           
    [Implemented,
     Description("Get the contents of Ec1"),
     WmiMethodId(9)] void GetEC1AsEc([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                     ] uint32 BlockIndex,
                                     [out] Vendor_EC1 Ec1);
                           
    [Implemented,
     Description("Get the contents of Ec2"),
     WmiMethodId(10)] void GetEC2AsEc([in, 
                                  Description("Index of block of data to fire"),
                                 Values{"0", "1", "2", "3"},
                                 ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                     ] uint32 BlockIndex,
                                      [out] Vendor_EC2 Ec2);

    [Implemented,
     Description("Cause driver to unregister device with WMI"),
     WmiMethodId(11)] void UnregisterFromWmi();

};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing data"),
 guid("{15D851E1-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass1 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("boolean data")
    ] boolean Xboolean;

    [WmiDataId(2),
     Description("unsigned character data")
    ] uint8 Xuint8;

    [WmiDataId(3),
     Description("unsigned short data")
    ] uint16 Xuint16;

    [WmiDataId(4),
     Description("unsigned long data")
    ] uint32 Xuint32;

    [WmiDataId(5),
     Description("unsigned long long data")
    ] uint64 Xuint64;

    [WmiDataId(6),
     Description("signed byte data")
    ] sint8 Xint8;

    [WmiDataId(7),
     Description("singed short data")
    ] sint16 Xint16;

    [WmiDataId(8),
     Description("singed long data")
    ] sint32 Xint32;

    [WmiDataId(9),
     Description("signed long long data")
    ] sint64 Xint64;

    [WmiDataId(10),
     Description("absolute or relative date and time")
    ] datetime Xdatetime;
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing embedded class 1"),
 guid("{15D851E2-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass2 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("Embedded class data")
    ] Vendor_EC1 EmbeddedClass1;
    
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing a fixed length array embedded class 1"),
 guid("{15D851E3-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass3 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("Fixed length array of 4 embedded classes")
    ] Vendor_EC1 EmbeddedClass1[4];
    
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing a variable length array embedded class 1"),
 guid("{15D851E4-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass4 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("Number of elements in array")
    ] uint32 Count;
    [WmiDataId(2),
     Description("Variable length array of embedded classes. Count specifies the number of elements in the array"),
     WmiSizeIs("Count")] Vendor_EC1 EmbeddedClass1[];
    
};
[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing embedded class 2"),
 guid("{15D851E5-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass5 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1)] Vendor_EC2 EmbeddedClass2;
    
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing a fixed length array of embedded class 2"),
 guid("{15D851E6-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass6 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1)] Vendor_EC2 EmbeddedClass2[4];
    
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event containing a variable length array of embedded class 2"),
 guid("{15D851E7-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventClass7 : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("Number of elements in array")
    ] uint32 Count;
    [WmiDataId(2),
     Description("Variable length array of embedded classes. Count specifies the number of elements in the array"),
     WmiSizeIs("Count")] Vendor_EC2 EmbeddedClass2[];
    
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Event used to illustrate an event reference"),
 guid("{15D851E8-6539-11d1-A529-00A0C9062910}")]
class Vendor_EventReferenceClass : WmiEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [WmiDataId(1),
     Description("boolean data")
    ] boolean Xboolean;

    [WmiDataId(2),
     Description("unsigned character data")
    ] uint8 Xuint8;

    [WmiDataId(3),
     Description("unsigned short data")
    ] uint16 Xuint16;

    [WmiDataId(4),
     Description("unsigned long data")
    ] uint32 Xuint32;

    [WmiDataId(5),
     Description("unsigned long long data")
    ] uint64 Xuint64;

    [WmiDataId(6),
     Description("signed byte data")
    ] sint8 Xint8;

    [WmiDataId(7),
     Description("singed short data")
    ] sint16 Xint16;

    [WmiDataId(8),
     Description("singed long data")
    ] sint32 Xint32;

    [WmiDataId(9),
     Description("signed long long data")
    ] sint64 Xint64;

    [WmiDataId(10),
     Description("absolute or relative date and time")
    ] datetime Xdatetime;
};



[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Locale("MS\\0x409"),
 Description("Method that fire events"),
 guid("{15D851F9-6539-11d1-A529-00A0C9062910}")]
class Vendor_FireEvent
{
    [key, read] 
     string InstanceName;
    [read] boolean Active;

    [Implemented,
     Description("Method to fire an event"),
     WmiMethodId(1)] void FireEvent([in,
                                     Description("Type of WNODE to fire"),
                                     Values{"0", "1"},
                                     ValueMap{"WNODE all data",
                                              "WNODE single instance"}
                                    ] uint32 WnodeType,
                                    [in,
                                     description("Which type of event to fire"),
                                     Values{"1", "2", "5", "8"},
                                     ValueMap{"Class 1 data",
                                              "Embedded class 1 data",
                                              "Embedded class 2 data",
                                              "Event Reference"}
                                    ] uint32 DataType,
                                    [in,
                                     Description("Index of block of data to fire"),
                                     Values{"0", "1", "2", "3"},
                                     ValueMap{"Block 1",
                                              "Block 2",
                                              "Block 3",
                                              "Block 4"}
                                    ] uint32 BlockIndex);

};