zig

mi.h (146572B) - Raw

---

 /**
  * This file has no copyright assigned and is placed in the Public Domain.
  * This file is part of the mingw-w64 runtime package.
  * No warranty is given; refer to the file DISCLAIMER.PD within this package.
  */
 
 #include <winapifamily.h>
 
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 
 #ifndef _MI_h
 #define _MI_h
 
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
 #pragma pack(push, 8)
 
 #if defined(MI_CHAR_TYPE)
 #if (MI_CHAR_TYPE != 1) && (MI_CHAR_TYPE != 2)
 #error "MI_CHAR_TYPE must be 1 or 2"
 #endif
 #else
 #define MI_CHAR_TYPE 2
 #endif
 
 #if (MI_CHAR_TYPE == 2)
 #define MI_USE_WCHAR
 #endif
 
 #ifndef MI_CONST
 #define MI_CONST const
 #endif
 
 #define MI_MAJOR ((MI_Uint32)1)
 #define MI_MINOR ((MI_Uint32)0)
 #define MI_REVISON ((MI_Uint32)0)
 #define MI_MAKE_VERSION(MAJ, MIN, REV) ((MAJ << 16) | (MIN << 8) | REV)
 #define MI_VERSION MI_MAKE_VERSION(MI_MAJOR, MI_MINOR, MI_REVISON)
 
 #define MI_UNREFERENCED_PARAMETER(P) (P)
 
 #define MI_EXPORT __declspec(dllexport)
 
 #define MI_MAIN_CALL __cdecl
 
 #define MI_CALL __stdcall
 
 #ifdef _MANAGED_PURE
 #define MI_INLINE_CALL
 #else
 #define MI_INLINE_CALL MI_CALL
 #endif
 
 #define MI_INLINE static __inline
 
 #define MI_OFFSETOF(STRUCT,FIELD) (((ptrdiff_t)&(((STRUCT*)1)->FIELD))-1)
 
 #ifdef __cplusplus
 #define MI_EXTERN_C extern "C"
 #else
 #define MI_EXTERN_C extern
 #endif
 
 #define MI_COUNT(X) (sizeof(X)/sizeof(X[0]))
 
 #if (MI_CHAR_TYPE == 1)
 #define MI_T(STR) STR
 #else
 #define MI_T(STR) L##STR
 #endif
 
 #define MI_LL(X) X##i64
 #define MI_ULL(X) X##ui64
 
 typedef struct _MI_Server MI_Server;
 typedef struct _MI_Context MI_Context;
 typedef struct _MI_ClassDecl MI_ClassDecl;
 typedef struct _MI_Instance MI_Instance;
 typedef struct _MI_Filter MI_Filter;
 typedef struct _MI_PropertySet MI_PropertySet;
 typedef struct _MI_Qualifier MI_Qualifier;
 typedef struct _MI_Session MI_Session;
 typedef struct _MI_ServerFT MI_ServerFT;
 typedef struct _MI_ProviderFT MI_ProviderFT;
 typedef struct _MI_PropertySetFT MI_PropertySetFT;
 typedef struct _MI_InstanceFT MI_InstanceFT;
 typedef struct _MI_ContextFT MI_ContextFT;
 typedef struct _MI_FilterFT MI_FilterFT;
 typedef struct _MI_Class MI_Class;
 typedef struct _MI_InstanceExFT MI_InstanceExFT;
 
 typedef enum _MI_Result {
   MI_RESULT_OK = 0,
   MI_RESULT_FAILED = 1,
   MI_RESULT_ACCESS_DENIED = 2,
   MI_RESULT_INVALID_NAMESPACE = 3,
   MI_RESULT_INVALID_PARAMETER = 4,
   MI_RESULT_INVALID_CLASS = 5,
   MI_RESULT_NOT_FOUND = 6,
   MI_RESULT_NOT_SUPPORTED = 7,
   MI_RESULT_CLASS_HAS_CHILDREN = 8,
   MI_RESULT_CLASS_HAS_INSTANCES = 9,
   MI_RESULT_INVALID_SUPERCLASS = 10,
   MI_RESULT_ALREADY_EXISTS = 11,
   MI_RESULT_NO_SUCH_PROPERTY = 12,
   MI_RESULT_TYPE_MISMATCH = 13,
   MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED = 14,
   MI_RESULT_INVALID_QUERY = 15,
   MI_RESULT_METHOD_NOT_AVAILABLE = 16,
   MI_RESULT_METHOD_NOT_FOUND = 17,
   MI_RESULT_NAMESPACE_NOT_EMPTY = 20,
   MI_RESULT_INVALID_ENUMERATION_CONTEXT = 21,
   MI_RESULT_INVALID_OPERATION_TIMEOUT = 22,
   MI_RESULT_PULL_HAS_BEEN_ABANDONED = 23,
   MI_RESULT_PULL_CANNOT_BE_ABANDONED = 24,
   MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED = 25,
   MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED = 26,
   MI_RESULT_SERVER_LIMITS_EXCEEDED = 27,
   MI_RESULT_SERVER_IS_SHUTTING_DOWN = 28
 } MI_Result;
 
 typedef enum _MI_ErrorCategory {
   MI_ERRORCATEGORY_NOT_SPECIFIED = 0,
   MI_ERRORCATEGORY_OPEN_ERROR = 1,
   MI_ERRORCATEGORY_CLOS_EERROR = 2,
   MI_ERRORCATEGORY_DEVICE_ERROR = 3,
   MI_ERRORCATEGORY_DEADLOCK_DETECTED = 4,
   MI_ERRORCATEGORY_INVALID_ARGUMENT = 5,
   MI_ERRORCATEGORY_INVALID_DATA = 6,
   MI_ERRORCATEGORY_INVALID_OPERATION = 7,
   MI_ERRORCATEGORY_INVALID_RESULT = 8,
   MI_ERRORCATEGORY_INVALID_TYPE = 9,
   MI_ERRORCATEGORY_METADATA_ERROR = 10,
   MI_ERRORCATEGORY_NOT_IMPLEMENTED = 11,
   MI_ERRORCATEGORY_NOT_INSTALLED = 12,
   MI_ERRORCATEGORY_OBJECT_NOT_FOUND = 13,
   MI_ERRORCATEGORY_OPERATION_STOPPED = 14,
   MI_ERRORCATEGORY_OPERATION_TIMEOUT = 15,
   MI_ERRORCATEGORY_SYNTAX_ERROR = 16,
   MI_ERRORCATEGORY_PARSER_ERROR = 17,
   MI_ERRORCATEGORY_ACCESS_DENIED = 18,
   MI_ERRORCATEGORY_RESOURCE_BUSY = 19,
   MI_ERRORCATEGORY_RESOURCE_EXISTS = 20,
   MI_ERRORCATEGORY_RESOURCE_UNAVAILABLE = 21,
   MI_ERRORCATEGORY_READ_ERROR = 22,
   MI_ERRORCATEGORY_WRITE_ERROR = 23,
   MI_ERRORCATEGORY_FROM_STDERR = 24,
   MI_ERRORCATEGORY_SECURITY_ERROR = 25,
   MI_ERRORCATEGORY_PROTOCOL_ERROR = 26,
   MI_ERRORCATEGORY_CONNECTION_ERROR = 27,
   MI_ERRORCATEGORY_AUTHENTICATION_ERROR = 28,
   MI_ERRORCATEGORY_LIMITS_EXCEEDED = 29,
   MI_ERRORCATEGORY_QUOTA_EXCEEDED = 30,
   MI_ERRORCATEGORY_NOT_ENABLED = 31
 } MI_ErrorCategory;
 
 typedef enum _MI_PromptType {
   MI_PROMPTTYPE_NORMAL,
   MI_PROMPTTYPE_CRITICAL
 } MI_PromptType;
 
 typedef enum _MI_CallbackMode {
   MI_CALLBACKMODE_REPORT,
   MI_CALLBACKMODE_INQUIRE,
   MI_CALLBACKMODE_IGNORE
 } MI_CallbackMode;
 
 typedef enum _MI_ProviderArchitecture {
   MI_PROVIDER_ARCHITECTURE_32BIT,
   MI_PROVIDER_ARCHITECTURE_64BIT
 } MI_ProviderArchitecture;
 
 #define MI_FLAG_CLASS (1 << 0)
 #define MI_FLAG_METHOD (1 << 1)
 #define MI_FLAG_PROPERTY (1 << 2)
 #define MI_FLAG_PARAMETER (1 << 3)
 #define MI_FLAG_ASSOCIATION (1 << 4)
 #define MI_FLAG_INDICATION (1 << 5)
 #define MI_FLAG_REFERENCE (1 << 6)
 #define MI_FLAG_ANY (1|2|4|8|16|32|64)
 
 #define MI_FLAG_ENABLEOVERRIDE (1 << 7)
 #define MI_FLAG_DISABLEOVERRIDE (1 << 8)
 #define MI_FLAG_RESTRICTED (1 << 9)
 #define MI_FLAG_TOSUBCLASS (1 << 10)
 #define MI_FLAG_TRANSLATABLE (1 << 11)
 
 #define MI_FLAG_KEY (1 << 12)
 #define MI_FLAG_IN (1 << 13)
 #define MI_FLAG_OUT (1 << 14)
 #define MI_FLAG_REQUIRED (1 << 15)
 #define MI_FLAG_STATIC (1 << 16)
 #define MI_FLAG_ABSTRACT (1 << 17)
 #define MI_FLAG_TERMINAL (1 << 18)
 #define MI_FLAG_EXPENSIVE (1 << 19)
 #define MI_FLAG_STREAM (1 << 20)
 #define MI_FLAG_READONLY (1 << 21)
 
 #define MI_FLAG_EXTENDED (1 << 12)
 #define MI_FLAG_NOT_MODIFIED (1 << 25)
 #define MI_FLAG_VERSION (1<<26|1<<27|1<<28)
 #define MI_FLAG_NULL (1 << 29)
 #define MI_FLAG_BORROW (1 << 30)
 #define MI_FLAG_ADOPT ((MI_Uint32)(1 << 31))
 
 typedef enum _MI_Type {
   MI_BOOLEAN = 0,
   MI_UINT8 = 1,
   MI_SINT8 = 2,
   MI_UINT16 = 3,
   MI_SINT16 = 4,
   MI_UINT32 = 5,
   MI_SINT32 = 6,
   MI_UINT64 = 7,
   MI_SINT64 = 8,
   MI_REAL32 = 9,
   MI_REAL64 = 10,
   MI_CHAR16 = 11,
   MI_DATETIME = 12,
   MI_STRING = 13,
   MI_REFERENCE = 14,
   MI_INSTANCE = 15,
   MI_BOOLEANA = 16,
   MI_UINT8A = 17,
   MI_SINT8A = 18,
   MI_UINT16A = 19,
   MI_SINT16A = 20,
   MI_UINT32A = 21,
   MI_SINT32A = 22,
   MI_UINT64A = 23,
   MI_SINT64A = 24,
   MI_REAL32A = 25,
   MI_REAL64A = 26,
   MI_CHAR16A = 27,
   MI_DATETIMEA = 28,
   MI_STRINGA = 29,
   MI_REFERENCEA = 30,
   MI_INSTANCEA = 31,
   MI_ARRAY = 16
 } MI_Type;
 
 typedef unsigned char MI_Boolean;
 typedef unsigned char MI_Uint8;
 typedef signed char MI_Sint8;
 typedef unsigned short MI_Uint16;
 typedef signed short MI_Sint16;
 typedef unsigned int MI_Uint32;
 typedef signed int MI_Sint32;
 
 typedef unsigned __int64 MI_Uint64;
 typedef signed __int64 MI_Sint64;
 
 typedef float MI_Real32;
 typedef double MI_Real64;
 typedef unsigned short MI_Char16;
 
 #if (MI_CHAR_TYPE == 1)
 typedef char MI_Char;
 #else
 typedef wchar_t MI_Char;
 #endif
 
 typedef MI_Char* MI_StringPtr;
 typedef const MI_Char* MI_ConstStringPtr;
 
 #define MI_TRUE ((MI_Boolean)1)
 #define MI_FALSE ((MI_Boolean)0)
 
 typedef struct _MI_Timestamp {
   MI_Uint32 year;
   MI_Uint32 month;
   MI_Uint32 day;
   MI_Uint32 hour;
   MI_Uint32 minute;
   MI_Uint32 second;
   MI_Uint32 microseconds;
   MI_Sint32 utc;
 } MI_Timestamp;
 
 typedef struct _MI_Interval {
   MI_Uint32 days;
   MI_Uint32 hours;
   MI_Uint32 minutes;
   MI_Uint32 seconds;
   MI_Uint32 microseconds;
   MI_Uint32 __padding1;
   MI_Uint32 __padding2;
   MI_Uint32 __padding3;
 } MI_Interval;
 
 typedef struct _MI_Datetime {
   MI_Uint32 isTimestamp;
   union {
     MI_Timestamp timestamp;
     MI_Interval interval;
   } u;
 } MI_Datetime;
 
 typedef struct _MI_BooleanA {
   MI_Boolean* data;
   MI_Uint32 size;
 } MI_BooleanA;
 
 typedef struct _MI_Uint8A {
   MI_Uint8* data;
   MI_Uint32 size;
 } MI_Uint8A;
 
 typedef struct _MI_Sint8A {
   MI_Sint8* data;
   MI_Uint32 size;
 } MI_Sint8A;
 
 typedef struct _MI_Uint16A {
   MI_Uint16* data;
   MI_Uint32 size;
 } MI_Uint16A;
 
 typedef struct _MI_Sint16A {
   MI_Sint16* data;
   MI_Uint32 size;
 } MI_Sint16A;
 
 typedef struct _MI_Uint32A {
   MI_Uint32* data;
   MI_Uint32 size;
 } MI_Uint32A;
 
 typedef struct _MI_Sint32A {
   MI_Sint32* data;
   MI_Uint32 size;
 } MI_Sint32A;
 
 typedef struct _MI_Uint64A {
   MI_Uint64* data;
   MI_Uint32 size;
 } MI_Uint64A;
 
 typedef struct _MI_Sint64A {
   MI_Sint64* data;
   MI_Uint32 size;
 } MI_Sint64A;
 
 typedef struct _MI_Real32A {
   MI_Real32* data;
   MI_Uint32 size;
 } MI_Real32A;
 
 typedef struct _MI_Real64A {
   MI_Real64* data;
   MI_Uint32 size;
 } MI_Real64A;
 
 typedef struct _MI_Char16A {
   MI_Char16* data;
   MI_Uint32 size;
 } MI_Char16A;
 
 typedef struct _MI_DatetimeA {
   MI_Datetime* data;
   MI_Uint32 size;
 } MI_DatetimeA;
 
 typedef struct _MI_StringA {
   MI_Char** data;
   MI_Uint32 size;
 } MI_StringA;
 
 typedef struct _MI_ReferenceA {
   struct _MI_Instance** data;
   MI_Uint32 size;
 } MI_ReferenceA;
 
 typedef struct _MI_InstanceA {
   MI_Instance** data;
   MI_Uint32 size;
 } MI_InstanceA;
 
 typedef struct _MI_Array {
   void* data;
   MI_Uint32 size;
 } MI_Array;
 
 typedef struct _MI_ConstBooleanA {
   MI_CONST MI_Boolean* data;
   MI_Uint32 size;
 } MI_ConstBooleanA;
 
 typedef struct _MI_ConstUint8A {
   MI_CONST MI_Uint8* data;
   MI_Uint32 size;
 } MI_ConstUint8A;
 
 typedef struct _MI_ConstSint8A {
   MI_CONST MI_Sint8* data;
   MI_Uint32 size;
 } MI_ConstSint8A;
 
 typedef struct _MI_ConstUint16A {
   MI_CONST MI_Uint16* data;
   MI_Uint32 size;
 } MI_ConstUint16A;
 
 typedef struct _MI_ConstSint16A {
   MI_CONST MI_Sint16* data;
   MI_Uint32 size;
 } MI_ConstSint16A;
 
 typedef struct _MI_ConstUint32A {
   MI_CONST MI_Uint32* data;
   MI_Uint32 size;
 } MI_ConstUint32A;
 
 typedef struct _MI_ConstSint32A {
   MI_CONST MI_Sint32* data;
   MI_Uint32 size;
 } MI_ConstSint32A;
 
 typedef struct _MI_ConstUint64A {
   MI_CONST MI_Uint64* data;
   MI_Uint32 size;
 } MI_ConstUint64A;
 
 typedef struct _MI_ConstSint64A {
   MI_CONST MI_Sint64* data;
   MI_Uint32 size;
 } MI_ConstSint64A;
 
 typedef struct _MI_ConstReal32A {
   MI_CONST MI_Real32* data;
   MI_Uint32 size;
 } MI_ConstReal32A;
 
 typedef struct _MI_ConstReal64A {
   MI_CONST MI_Real64* data;
   MI_Uint32 size;
 } MI_ConstReal64A;
 
 typedef struct _MI_ConstChar16A {
   MI_CONST MI_Char16* data;
   MI_Uint32 size;
 } MI_ConstChar16A;
 
 typedef struct _MI_ConstDatetimeA {
   MI_CONST MI_Datetime* data;
   MI_Uint32 size;
 } MI_ConstDatetimeA;
 
 typedef struct _MI_ConstStringA {
   MI_CONST MI_Char* MI_CONST* data;
   MI_Uint32 size;
 } MI_ConstStringA;
 
 typedef struct _MI_ConstReferenceA {
   MI_CONST MI_Instance* MI_CONST* data;
   MI_Uint32 size;
 } MI_ConstReferenceA;
 
 typedef struct _MI_ConstInstanceA {
   MI_CONST MI_Instance* MI_CONST* data;
   MI_Uint32 size;
 } MI_ConstInstanceA;
 
 typedef union _MI_Value {
   MI_Boolean boolean;
   MI_Uint8 uint8;
   MI_Sint8 sint8;
   MI_Uint16 uint16;
   MI_Sint16 sint16;
   MI_Uint32 uint32;
   MI_Sint32 sint32;
   MI_Uint64 uint64;
   MI_Sint64 sint64;
   MI_Real32 real32;
   MI_Real64 real64;
   MI_Char16 char16;
   MI_Datetime datetime;
   MI_Char* string;
   MI_Instance* instance;
   MI_Instance* reference;
   MI_BooleanA booleana;
   MI_Uint8A uint8a;
   MI_Sint8A sint8a;
   MI_Uint16A uint16a;
   MI_Sint16A sint16a;
   MI_Uint32A uint32a;
   MI_Sint32A sint32a;
   MI_Uint64A uint64a;
   MI_Sint64A sint64a;
   MI_Real32A real32a;
   MI_Real64A real64a;
   MI_Char16A char16a;
   MI_DatetimeA datetimea;
   MI_StringA stringa;
   MI_ReferenceA referencea;
   MI_InstanceA instancea;
   MI_Array array;
 } MI_Value;
 
 typedef struct _MI_BooleanField {
   MI_Boolean value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_BooleanField;
 
 typedef struct _MI_Sint8Field {
   MI_Sint8 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint8Field;
 
 typedef struct _MI_Uint8Field {
   MI_Uint8 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint8Field;
 
 typedef struct _MI_Sint16Field {
   MI_Sint16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint16Field;
 
 typedef struct _MI_Uint16Field {
   MI_Uint16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint16Field;
 
 typedef struct _MI_Sint32Field {
   MI_Sint32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint32Field;
 
 typedef struct _MI_Uint32Field {
   MI_Uint32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint32Field;
 
 typedef struct _MI_Sint64Field {
   MI_Sint64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint64Field;
 
 typedef struct _MI_Uint64Field {
   MI_Uint64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint64Field;
 
 typedef struct _MI_Real32Field {
   MI_Real32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Real32Field;
 
 typedef struct _MI_Real64Field {
   MI_Real64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Real64Field;
 
 typedef struct _MI_Char16Field {
   MI_Char16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Char16Field;
 
 typedef struct _MI_DatetimeField {
   MI_Datetime value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_DatetimeField;
 
 typedef struct _MI_StringField {
   MI_Char* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_StringField;
 
 typedef struct _MI_ReferenceField {
   MI_Instance* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ReferenceField;
 
 typedef struct _MI_InstanceField {
   MI_Instance* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_InstanceField;
 
 typedef struct _MI_BooleanAField {
   MI_BooleanA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_BooleanAField;
 
 typedef struct _MI_Uint8AField {
   MI_Uint8A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint8AField;
 
 typedef struct _MI_Sint8AField {
   MI_Sint8A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint8AField;
 
 typedef struct _MI_Uint16AField {
   MI_Uint16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint16AField;
 
 typedef struct _MI_Sint16AField {
   MI_Sint16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint16AField;
 
 typedef struct _MI_Uint32AField {
   MI_Uint32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint32AField;
 
 typedef struct _MI_Sint32AField {
   MI_Sint32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint32AField;
 
 typedef struct _MI_Uint64AField {
   MI_Uint64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Uint64AField;
 
 typedef struct _MI_Sint64AField {
   MI_Sint64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Sint64AField;
 
 typedef struct _MI_Real32AField {
   MI_Real32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Real32AField;
 
 typedef struct _MI_Real64AField {
   MI_Real64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Real64AField;
 
 typedef struct _MI_Char16AField {
   MI_Char16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_Char16AField;
 
 typedef struct _MI_DatetimeAField {
   MI_DatetimeA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_DatetimeAField;
 
 typedef struct _MI_StringAField {
   MI_StringA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_StringAField;
 
 typedef struct _MI_ReferenceAField {
   MI_ReferenceA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ReferenceAField;
 
 typedef struct _MI_InstanceAField {
   MI_InstanceA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_InstanceAField;
 
 typedef struct _MI_ArrayField {
   MI_Array value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ArrayField;
 
 typedef struct _MI_ConstBooleanField {
   MI_Boolean value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstBooleanField;
 
 typedef struct _MI_ConstSint8Field {
   MI_Sint8 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint8Field;
 
 typedef struct _MI_ConstUint8Field {
   MI_Uint8 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint8Field;
 
 typedef struct _MI_ConstSint16Field {
   MI_Sint16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint16Field;
 
 typedef struct _MI_ConstUint16Field {
   MI_Uint16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint16Field;
 
 typedef struct _MI_ConstSint32Field {
   MI_Sint32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint32Field;
 
 typedef struct _MI_ConstUint32Field {
   MI_Uint32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint32Field;
 
 typedef struct _MI_ConstSint64Field {
   MI_Sint64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint64Field;
 
 typedef struct _MI_ConstUint64Field {
   MI_Uint64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint64Field;
 
 typedef struct _MI_ConstReal32Field {
   MI_Real32 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReal32Field;
 
 typedef struct _MI_ConstReal64Field {
   MI_Real64 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReal64Field;
 
 typedef struct _MI_ConstChar16Field {
   MI_Char16 value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstChar16Field;
 
 typedef struct _MI_ConstDatetimeField {
   MI_Datetime value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstDatetimeField;
 
 typedef struct _MI_ConstStringField {
   MI_CONST MI_Char* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstStringField;
 
 typedef struct _MI_ConstReferenceField {
   MI_CONST MI_Instance* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReferenceField;
 
 typedef struct _MI_ConstInstanceField {
   MI_CONST MI_Instance* value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstInstanceField;
 
 typedef struct _MI_ConstBooleanAField {
   MI_ConstBooleanA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstBooleanAField;
 
 typedef struct _MI_ConstUint8AField {
   MI_ConstUint8A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint8AField;
 
 typedef struct _MI_ConstSint8AField {
   MI_ConstSint8A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint8AField;
 
 typedef struct _MI_ConstUint16AField {
   MI_ConstUint16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint16AField;
 
 typedef struct _MI_ConstSint16AField {
   MI_ConstSint16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint16AField;
 
 typedef struct _MI_ConstUint32AField {
   MI_ConstUint32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint32AField;
 
 typedef struct _MI_ConstSint32AField {
   MI_ConstSint32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint32AField;
 
 typedef struct _MI_ConstUint64AField {
   MI_ConstUint64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstUint64AField;
 
 typedef struct _MI_ConstSint64AField {
   MI_ConstSint64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstSint64AField;
 
 typedef struct _MI_ConstReal32AField {
   MI_ConstReal32A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReal32AField;
 
 typedef struct _MI_ConstReal64AField {
   MI_ConstReal64A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReal64AField;
 
 typedef struct _MI_ConstChar16AField {
   MI_ConstChar16A value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstChar16AField;
 
 typedef struct _MI_ConstDatetimeAField {
   MI_ConstDatetimeA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstDatetimeAField;
 
 typedef struct _MI_ConstStringAField {
   MI_ConstStringA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstStringAField;
 
 typedef struct _MI_ConstReferenceAField {
   MI_ConstReferenceA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstReferenceAField;
 
 typedef struct _MI_ConstInstanceAField {
   MI_ConstInstanceA value;
   MI_Boolean exists;
   MI_Uint8 flags;
 } MI_ConstInstanceAField;
 
 struct _MI_ServerFT {
   MI_Result (MI_CALL *GetVersion)(MI_Uint32* version);
   MI_Result (MI_CALL *GetSystemName)(const MI_Char** systemName);
 };
 
 struct _MI_Server {
   const MI_ServerFT* serverFT;
   const MI_ContextFT* contextFT;
   const MI_InstanceFT* instanceFT;
   const MI_PropertySetFT* propertySetFT;
   const MI_FilterFT* filterFT;
 };
 
 MI_Result MI_CALL MI_Server_GetVersion(MI_Uint32* version);
 MI_Result MI_CALL MI_Server_GetSystemName(const MI_Char** systemName);
 
 struct _MI_FilterFT {
   MI_Result (MI_CALL *Evaluate)(const MI_Filter* self, const MI_Instance* instance, MI_Boolean* result);
   MI_Result (MI_CALL *GetExpression)(const MI_Filter* self, const MI_Char** queryLang, const MI_Char** queryExpr);
 };
 
 struct _MI_Filter {
   const MI_FilterFT* ft;
   ptrdiff_t reserved[3];
 };
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Filter_Evaluate(const MI_Filter* self, const MI_Instance* instance, MI_Boolean* result) {
   if (self && self->ft) {
     return self->ft->Evaluate(self, instance, result);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Filter_GetExpression(const MI_Filter* self, const MI_Char** queryLang, const MI_Char** queryExpr) {
   if (self && self->ft) {
     return self->ft->GetExpression(self, queryLang, queryExpr);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 struct _MI_PropertySetFT {
   MI_Result (MI_CALL *GetElementCount)(const MI_PropertySet* self, MI_Uint32* count);
   MI_Result (MI_CALL *ContainsElement)(const MI_PropertySet* self, const MI_Char* name, MI_Boolean* flag);
   MI_Result (MI_CALL *AddElement)(MI_PropertySet* self, const MI_Char* name);
   MI_Result (MI_CALL *GetElementAt)(const MI_PropertySet* self, MI_Uint32 index, const MI_Char** name);
   MI_Result (MI_CALL *Clear)(MI_PropertySet* self);
   MI_Result (MI_CALL *Destruct)(MI_PropertySet* self);
   MI_Result (MI_CALL *Delete)(MI_PropertySet* self);
   MI_Result (MI_CALL *Clone)(const MI_PropertySet* self, MI_PropertySet** newPropertySet);
 };
 
 struct _MI_PropertySet {
   const MI_PropertySetFT* ft;
   ptrdiff_t reserved[3];
 };
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_GetElementCount(const MI_PropertySet* self, MI_Uint32* count) {
   if (self && self->ft) {
     return self->ft->GetElementCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_ContainsElement(const MI_PropertySet* self, const MI_Char* name, MI_Boolean* flag) {
   if (self && self->ft) {
     return self->ft->ContainsElement(self, name, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_AddElement(MI_PropertySet* self, const MI_Char* name) {
   if (self && self->ft) {
     return self->ft->AddElement(self, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_GetElementAt(const MI_PropertySet* self, MI_Uint32 index, const MI_Char** name) {
   if (self && self->ft) {
     return self->ft->GetElementAt(self, index, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_Clear(MI_PropertySet* self) {
   if (self && self->ft) {
     return self->ft->Clear(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_Destruct(MI_PropertySet* self) {
   if (self && self->ft) {
     return self->ft->Destruct(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_Delete(MI_PropertySet* self) {
   if (self && self->ft) {
     return self->ft->Delete(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_PropertySet_Clone(const MI_PropertySet* self, MI_PropertySet** newPropertySet) {
   if (self && self->ft) {
     return self->ft->Clone(self, newPropertySet);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 typedef struct _MI_ObjectDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   MI_Qualifier MI_CONST* MI_CONST* qualifiers;
   MI_Uint32 numQualifiers;
   struct _MI_PropertyDecl MI_CONST* MI_CONST* properties;
   MI_Uint32 numProperties;
   MI_Uint32 size;
 } MI_ObjectDecl;
 
 struct _MI_ClassDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   struct _MI_Qualifier MI_CONST* MI_CONST* qualifiers;
   MI_Uint32 numQualifiers;
   struct _MI_PropertyDecl MI_CONST* MI_CONST* properties;
   MI_Uint32 numProperties;
   MI_Uint32 size;
   MI_CONST MI_Char* superClass;
   MI_ClassDecl MI_CONST* superClassDecl;
   struct _MI_MethodDecl MI_CONST* MI_CONST* methods;
   MI_Uint32 numMethods;
   struct _MI_SchemaDecl MI_CONST* schema;
   MI_CONST MI_ProviderFT* providerFT;
   MI_Class *owningClass;
 };
 
 typedef struct _MI_FeatureDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   MI_Qualifier MI_CONST* MI_CONST * qualifiers;
   MI_Uint32 numQualifiers;
 } MI_FeatureDecl;
 
 typedef struct _MI_ParameterDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   MI_Qualifier MI_CONST* MI_CONST* qualifiers;
   MI_Uint32 numQualifiers;
   MI_Uint32 type;
   MI_CONST MI_Char* className;
   MI_Uint32 subscript;
   MI_Uint32 offset;
 } MI_ParameterDecl;
 
 typedef struct _MI_PropertyDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   MI_Qualifier MI_CONST* MI_CONST* qualifiers;
   MI_Uint32 numQualifiers;
   MI_Uint32 type;
   MI_CONST MI_Char* className;
   MI_Uint32 subscript;
   MI_Uint32 offset;
   MI_CONST MI_Char* origin;
   MI_CONST MI_Char* propagator;
   MI_CONST void* value;
 } MI_PropertyDecl;
 
 typedef void (MI_CALL *MI_MethodDecl_Invoke)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Char* methodName, const MI_Instance* instanceName, const MI_Instance* parameters);
 
 typedef struct _MI_MethodDecl {
   MI_Uint32 flags;
   MI_Uint32 code;
   MI_CONST MI_Char* name;
   struct _MI_Qualifier MI_CONST* MI_CONST* qualifiers;
   MI_Uint32 numQualifiers;
   struct _MI_ParameterDecl MI_CONST* MI_CONST* parameters;
   MI_Uint32 numParameters;
   MI_Uint32 size;
   MI_Uint32 returnType;
   MI_CONST MI_Char* origin;
   MI_CONST MI_Char* propagator;
   struct _MI_SchemaDecl MI_CONST* schema;
   MI_MethodDecl_Invoke function;
 } MI_MethodDecl;
 
 typedef struct _MI_QualifierDecl {
   MI_CONST MI_Char* name;
   MI_Uint32 type;
   MI_Uint32 scope;
   MI_Uint32 flavor;
   MI_Uint32 subscript;
   MI_CONST void* value;
 } MI_QualifierDecl;
 
 struct _MI_Qualifier {
   MI_CONST MI_Char* name;
   MI_Uint32 type;
   MI_Uint32 flavor;
   MI_CONST void* value;
 };
 
 typedef struct _MI_SchemaDecl {
   MI_QualifierDecl MI_CONST* MI_CONST* qualifierDecls;
   MI_Uint32 numQualifierDecls;
   MI_ClassDecl MI_CONST* MI_CONST* classDecls;
   MI_Uint32 numClassDecls;
 } MI_SchemaDecl;
 
 typedef struct _MI_Module_Self MI_Module_Self;
 
 typedef void (MI_CALL *MI_ProviderFT_Load)(void** self, MI_Module_Self* selfModule, MI_Context* context);
 typedef void (MI_CALL *MI_ProviderFT_Unload)(void* self, MI_Context* context);
 typedef void (MI_CALL *MI_ProviderFT_GetInstance)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* instanceName, const MI_PropertySet* propertySet);
 typedef void (MI_CALL *MI_ProviderFT_EnumerateInstances)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_PropertySet* propertySet, MI_Boolean keysOnly, const MI_Filter* filter);
 typedef void (MI_CALL *MI_ProviderFT_CreateInstance)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* newInstance);
 typedef void (MI_CALL *MI_ProviderFT_ModifyInstance)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* modifiedInstance, const MI_PropertySet* propertySet);
 typedef void (MI_CALL *MI_ProviderFT_DeleteInstance)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* instanceName);
 typedef void (MI_CALL *MI_ProviderFT_AssociatorInstances)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* instanceName, const MI_Char* resultClass, const MI_Char* role, const MI_Char* resultRole, const MI_PropertySet* propertySet, MI_Boolean keysOnly, const MI_Filter* filter);
 typedef void (MI_CALL *MI_ProviderFT_ReferenceInstances)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Instance* instanceName, const MI_Char* role, const MI_PropertySet* propertySet, MI_Boolean keysOnly, const MI_Filter* filter);
 typedef void (MI_CALL *MI_ProviderFT_EnableIndications)(void* self, MI_Context* indicationsContext, const MI_Char* nameSpace, const MI_Char* className);
 typedef void (MI_CALL *MI_ProviderFT_DisableIndications)(void* self, MI_Context* indicationsContext, const MI_Char* nameSpace, const MI_Char* className);
 typedef void (MI_CALL *MI_ProviderFT_Subscribe)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Filter* filter, const MI_Char* bookmark, MI_Uint64 subscriptionID, void** subscriptionSelf);
 typedef void (MI_CALL *MI_ProviderFT_Unsubscribe)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, MI_Uint64 subscriptionID, void* subscriptionSelf);
 typedef void (MI_CALL *MI_ProviderFT_Invoke)(void* self, MI_Context* context, const MI_Char* nameSpace, const MI_Char* className, const MI_Char* methodName, const MI_Instance* instanceName, const MI_Instance* inputParameters);
 
 struct _MI_ProviderFT {
   MI_ProviderFT_Load Load;
   MI_ProviderFT_Unload Unload;
   MI_ProviderFT_GetInstance GetInstance;
   MI_ProviderFT_EnumerateInstances EnumerateInstances;
   MI_ProviderFT_CreateInstance CreateInstance;
   MI_ProviderFT_ModifyInstance ModifyInstance;
   MI_ProviderFT_DeleteInstance DeleteInstance;
   MI_ProviderFT_AssociatorInstances AssociatorInstances;
   MI_ProviderFT_ReferenceInstances ReferenceInstances;
   MI_ProviderFT_EnableIndications EnableIndications;
   MI_ProviderFT_DisableIndications DisableIndications;
   MI_ProviderFT_Subscribe Subscribe;
   MI_ProviderFT_Unsubscribe Unsubscribe;
   MI_ProviderFT_Invoke Invoke;
 };
 
 #define MI_MODULE_FLAG_STANDARD_QUALIFIERS (1 << 0)
 #define MI_MODULE_FLAG_DESCRIPTIONS (1 << 1)
 #define MI_MODULE_FLAG_VALUES (1 << 2)
 #define MI_MODULE_FLAG_MAPPING_STRINGS (1 << 3)
 #define MI_MODULE_FLAG_BOOLEANS (1 << 4)
 #define MI_MODULE_FLAG_CPLUSPLUS (1 << 5)
 #define MI_MODULE_FLAG_LOCALIZED (1 << 6)
 #define MI_MODULE_FLAG_FILTER_SUPPORT (1 << 7)
 
 typedef void (MI_CALL *MI_Module_Load)(MI_Module_Self** self, MI_Context* context);
 typedef void (MI_CALL *MI_Module_Unload)(MI_Module_Self* self, MI_Context* context);
 
 typedef struct _MI_Module {
   MI_Uint32 version;
   MI_Uint32 generatorVersion;
   MI_Uint32 flags;
   MI_Uint32 charSize;
   MI_SchemaDecl* schemaDecl;
   MI_Module_Load Load;
   MI_Module_Unload Unload;
   const MI_ProviderFT* dynamicProviderFT;
 } MI_Module;
 
 struct _MI_InstanceFT {
   MI_Result (MI_CALL *Clone)(const MI_Instance* self, MI_Instance** newInstance);
   MI_Result (MI_CALL *Destruct)(MI_Instance* self);
   MI_Result (MI_CALL *Delete)(MI_Instance* self);
   MI_Result (MI_CALL *IsA)(const MI_Instance* self, const MI_ClassDecl* classDecl, MI_Boolean* flag);
   MI_Result (MI_CALL *GetClassName)(const MI_Instance* self, const MI_Char** className);
   MI_Result (MI_CALL *SetNameSpace)(MI_Instance* self, const MI_Char* nameSpace);
   MI_Result (MI_CALL *GetNameSpace)(const MI_Instance* self, const MI_Char** nameSpace);
   MI_Result (MI_CALL *GetElementCount)(const MI_Instance* self, MI_Uint32* count);
   MI_Result (MI_CALL *AddElement)(MI_Instance* self, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags);
   MI_Result (MI_CALL *SetElement)(MI_Instance* self, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags);
   MI_Result (MI_CALL *SetElementAt)(MI_Instance* self, MI_Uint32 index, const MI_Value* value, MI_Type type, MI_Uint32 flags);
   MI_Result (MI_CALL *GetElement)(const MI_Instance* self, const MI_Char* name, MI_Value* value, MI_Type* type, MI_Uint32* flags, MI_Uint32* index);
   MI_Result (MI_CALL *GetElementAt)(const MI_Instance* self, MI_Uint32 index, const MI_Char** name, MI_Value* value, MI_Type* type, MI_Uint32* flags);
   MI_Result (MI_CALL *ClearElement)(MI_Instance* self, const MI_Char* name);
   MI_Result (MI_CALL *ClearElementAt)(MI_Instance* self, MI_Uint32 index);
   MI_Result (MI_CALL *GetServerName)(const MI_Instance* self, const MI_Char** name);
   MI_Result (MI_CALL *SetServerName)(MI_Instance* self, const MI_Char* name);
   MI_Result (MI_CALL *GetClass)(const MI_Instance* self, MI_Class** instanceClass);
 };
 
 struct _MI_InstanceExFT {
   MI_InstanceFT parent;
   MI_Result (MI_CALL *Normalize)(MI_Instance** self);
 };
 
 struct _MI_Instance {
   const MI_InstanceFT* ft;
   const MI_ClassDecl* classDecl;
   const MI_Char* serverName;
   const MI_Char* nameSpace;
   ptrdiff_t reserved[4];
 };
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_Clone(const MI_Instance* self, MI_Instance** newInstance) {
   if (self && self->ft) {
     return self->ft->Clone(self, newInstance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_Destruct(MI_Instance* self) {
   if (self && self->ft) {
     return self->ft->Destruct(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_Delete(MI_Instance* self) {
   if (self && self->ft) {
     return self->ft->Delete(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_IsA(const MI_Instance* self, const MI_ClassDecl* classDecl, MI_Boolean* flag) {
   if (self && self->ft) {
     return self->ft->IsA(self, classDecl, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetClassName(const MI_Instance* self, const MI_Char** className) {
   if (self && self->ft) {
     return self->ft->GetClassName(self, className);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_SetNameSpace(MI_Instance* self, const MI_Char* nameSpace) {
   if (self && self->ft) {
     return self->ft->SetNameSpace(self, nameSpace);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetNameSpace(const MI_Instance* self, const MI_Char** nameSpace) {
   if (self && self->ft) {
     return self->ft->GetNameSpace(self, nameSpace);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetElementCount(const MI_Instance* self, MI_Uint32* count) {
   if (self && self->ft) {
     return self->ft->GetElementCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_AddElement(MI_Instance* self, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->AddElement(self, name, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_SetElementAt(MI_Instance* self, MI_Uint32 index, const MI_Value* value, MI_Type type, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetElementAt(self, index, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_SetElement(MI_Instance* self, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetElement(self, name, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetElement(const MI_Instance* self, const MI_Char* name, MI_Value* value, MI_Type* type, MI_Uint32* flags, MI_Uint32* index) {
   if (self && self->ft) {
     return self->ft->GetElement(self, name, value, type, flags, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetElementAt(const MI_Instance* self, MI_Uint32 index, const MI_Char** name, MI_Value* value, MI_Type* type, MI_Uint32* flags) {
   if (self && self->ft) {
     return self->ft->GetElementAt(self, index, name, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_ClearElement(MI_Instance* self, const MI_Char* name) {
   if (self && self->ft) {
     return self->ft->ClearElement(self, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_ClearElementAt(MI_Instance* self, MI_Uint32 index) {
   if (self && self->ft) {
     return self->ft->ClearElementAt(self, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetServerName(const MI_Instance* self, const MI_Char** name) {
   if (self && self->ft) {
     return self->ft->GetServerName(self, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_SetServerName(MI_Instance* self, const MI_Char* name) {
   if (self && self->ft) {
     return self->ft->SetServerName(self, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_GetClass(const MI_Instance* self, MI_Class** instanceClass) {
   if (self && self->ft) {
     return self->ft->GetClass(self, instanceClass);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Instance_Normalize(MI_Instance** self) {
   MI_Instance* inst = *self;
   if (inst && inst->ft) {
     if (inst->classDecl->flags & MI_FLAG_EXTENDED) {
       MI_InstanceExFT* ft = (MI_InstanceExFT*)inst->ft;
       return ft->Normalize(self);
     } else {
       return MI_RESULT_OK;
     }
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_MAX_LOCALE_SIZE 128
 
 typedef enum _MI_LocaleType {
   MI_LOCALE_TYPE_REQUESTED_UI,
   MI_LOCALE_TYPE_REQUESTED_DATA,
   MI_LOCALE_TYPE_CLOSEST_UI,
   MI_LOCALE_TYPE_CLOSEST_DATA
 } MI_LocaleType;
 
 typedef enum _MI_CancellationReason {
   MI_REASON_NONE,
   MI_REASON_TIMEOUT,
   MI_REASON_SHUTDOWN,
   MI_REASON_SERVICESTOP
 } MI_CancellationReason;
 
 typedef void (MI_CALL *MI_CancelCallback)(MI_CancellationReason reason, void* callbackData);
 
 #define MI_WRITEMESSAGE_CHANNEL_WARNING 0
 #define MI_WRITEMESSAGE_CHANNEL_VERBOSE 1
 #define MI_WRITEMESSAGE_CHANNEL_DEBUG 2
 
 #define MI_RESULT_TYPE_MI MI_T("MI")
 #define MI_RESULT_TYPE_HRESULT MI_T("HRESULT")
 #define MI_RESULT_TYPE_WIN32 MI_T("WIN32")
 #define MI_RESULT_TYPE_ERRNO MI_T("ERRNO")
 
 struct _MI_ContextFT {
   MI_Result (MI_CALL *PostResult)(MI_Context* context, MI_Result result);
   MI_Result (MI_CALL *PostInstance)(MI_Context* context, const MI_Instance* instance);
   MI_Result (MI_CALL *PostIndication)(MI_Context* context, const MI_Instance* indication, MI_Uint32 subscriptionIDCount, const MI_Char* bookmark);
   MI_Result (MI_CALL *ConstructInstance)(MI_Context* context, const MI_ClassDecl* classDecl, MI_Instance* instance);
   MI_Result (MI_CALL *ConstructParameters)(MI_Context* context, const MI_MethodDecl* methodDecl, MI_Instance* instance);
   MI_Result (MI_CALL *NewInstance)(MI_Context* context, const MI_ClassDecl* classDecl, MI_Instance** instance);
   MI_Result (MI_CALL *NewDynamicInstance)(MI_Context* context, const MI_Char* className, MI_Uint32 flags, MI_Instance** instance);
   MI_Result (MI_CALL *NewParameters)(MI_Context* context, const MI_MethodDecl* methodDecl, MI_Instance** instance);
   MI_Result (MI_CALL *Canceled)(const MI_Context* context, MI_Boolean* flag);
   MI_Result (MI_CALL *GetLocale)(const MI_Context* context, MI_LocaleType localeType, MI_Char locale[MI_MAX_LOCALE_SIZE]);
   MI_Result (MI_CALL *RegisterCancel)(MI_Context* context, MI_CancelCallback callback, void* callbackData);
   MI_Result (MI_CALL *RequestUnload)(MI_Context* context);
   MI_Result (MI_CALL *RefuseUnload)(MI_Context* context);
   MI_Result (MI_CALL *GetLocalSession)(const MI_Context* context, MI_Session* session);
   MI_Result (MI_CALL *SetStringOption)(MI_Context* context, const MI_Char* name, const MI_Char* value);
   MI_Result (MI_CALL *GetStringOption)(MI_Context* context, const MI_Char* name, const MI_Char** value);
   MI_Result (MI_CALL *GetNumberOption)(MI_Context* context, const MI_Char *name, MI_Uint32* value);
   MI_Result (MI_CALL *GetCustomOption)(MI_Context* context, const MI_Char* name, MI_Type* valueType, MI_Value* value);
   MI_Result (MI_CALL *GetCustomOptionCount)(MI_Context* context, MI_Uint32* count);
   MI_Result (MI_CALL *GetCustomOptionAt)(MI_Context* context, MI_Uint32 index, const MI_Char** name, MI_Type* valueType, MI_Value* value);
   MI_Result (MI_CALL *WriteMessage)(MI_Context* context, MI_Uint32 channel, const MI_Char* message);
   MI_Result (MI_CALL *WriteProgress)(MI_Context* context, const MI_Char* activity, const MI_Char* currentOperation, const MI_Char* statusDescription, MI_Uint32 percentComplete, MI_Uint32 secondsRemaining);
   MI_Result (MI_CALL *WriteStreamParameter)(MI_Context* context, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags);
   MI_Result (MI_CALL *WriteCimError)(MI_Context* context, const MI_Instance *error, MI_Boolean *flag);
   MI_Result (MI_CALL *PromptUser)(MI_Context* context, const MI_Char* message, MI_PromptType promptType, MI_Boolean* result );
   MI_Result (MI_CALL *ShouldProcess)(MI_Context* context, const MI_Char* target, const MI_Char* action, MI_Boolean* result);
   MI_Result (MI_CALL *ShouldContinue)(MI_Context* context, const MI_Char* message, MI_Boolean* result);
   MI_Result (MI_CALL *PostError)(MI_Context* context, MI_Uint32 resultCode, const MI_Char* resultType, const MI_Char* errorMessage);
   MI_Result (MI_CALL *PostCimError)(MI_Context* context, const MI_Instance *error);
   MI_Result (MI_CALL *WriteError)(MI_Context* context, MI_Uint32 resultCode, const MI_Char* resultType, const MI_Char* errorMessage, MI_Boolean *flag);
 };
 
 struct _MI_Context {
   const MI_ContextFT* ft;
   ptrdiff_t reserved[3];
 };
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PostResult(MI_Context* context, MI_Result result) {
   if (context && context->ft) {
     return context->ft->PostResult(context, result);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PostCimError(MI_Context* context, const MI_Instance *error) {
   if (context && context->ft) {
     return context->ft->PostCimError(context, error);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PostError(MI_Context* context, MI_Uint32 resultCode, const MI_Char* resultType, const MI_Char* errorMessage) {
   if (context && context->ft) {
     return context->ft->PostError(context, resultCode, resultType, errorMessage);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PostInstance(MI_Context* context, const MI_Instance* instance) {
   if (context && context->ft) {
     return context->ft->PostInstance(context, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PostIndication(MI_Context* context, const MI_Instance* indication, MI_Uint32 subscriptionIDCount, const MI_Char* bookmark) {
   if (context && context->ft) {
     return context->ft->PostIndication(context, indication, subscriptionIDCount, bookmark);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_ConstructInstance(MI_Context* context, const MI_ClassDecl* classDecl, MI_Instance* instance) {
   if (context && context->ft) {
     return context->ft->ConstructInstance(context, classDecl, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_ConstructParameters(MI_Context* context, const MI_MethodDecl* methodDecl, MI_Instance* instance) {
   if (context && context->ft) {
     return context->ft->ConstructParameters(context, methodDecl, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_NewInstance(MI_Context* context, const MI_ClassDecl* classDecl, MI_Instance** instance) {
   if (context && context->ft) {
     return context->ft->NewInstance(context, classDecl, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_NewDynamicInstance(MI_Context* context, const MI_Char* className, MI_Uint32 flags, MI_Instance** instance) {
   if (context && context->ft) {
     return context->ft->NewDynamicInstance(context, className, flags, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_NewParameters(MI_Context* context, const MI_MethodDecl* methodDecl, MI_Instance** instance) {
   if (context && context->ft) {
     return context->ft->NewParameters(context, methodDecl, instance);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_Canceled(const MI_Context* context, MI_Boolean* flag) {
   if (context && context->ft) {
     return context->ft->Canceled(context, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetLocale(const MI_Context* context, MI_LocaleType localeType, MI_Char locale[MI_MAX_LOCALE_SIZE]) {
   if (locale) {
     locale[0] = L'\0';
   }
   if (context && context->ft) {
     return context->ft->GetLocale(context, localeType, locale);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_RegisterCancel(MI_Context* context, MI_CancelCallback callback, void* callbackData) {
   if (context && context->ft) {
     return context->ft->RegisterCancel(context, callback, callbackData);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_RequestUnload(MI_Context* context) {
   if (context && context->ft) {
     return context->ft->RequestUnload(context);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_RefuseUnload(MI_Context* context) {
   if (context && context->ft) {
     return context->ft->RefuseUnload(context);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 };
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetLocalSession(const MI_Context* context, MI_Session* session) {
   if (context && context->ft) {
     return context->ft->GetLocalSession(context, session);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_SetStringOption(MI_Context* context, const MI_Char* name, const MI_Char* value) {
   if (context && context->ft) {
     return context->ft->SetStringOption(context, name, value);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetStringOption(MI_Context* context, const MI_Char* name, const MI_Char** value) {
   if (context && context->ft) {
     return context->ft->GetStringOption(context, name, value);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetNumberOption(MI_Context* context, const MI_Char* name, MI_Uint32* value) {
   if (context && context->ft) {
     return context->ft->GetNumberOption(context, name, value);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetCustomOption(MI_Context* context, const MI_Char* name, MI_Type* valueType, MI_Value* value) {
   if (context && context->ft) {
     return context->ft->GetCustomOption(context, name, valueType,value);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetCustomOptionCount(MI_Context* context, MI_Uint32* count) {
   if (context && context->ft) {
     return context->ft->GetCustomOptionCount(context, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_GetCustomOptionAt(MI_Context* context, MI_Uint32 index, const MI_Char** name, MI_Type* valueType, MI_Value* value) {
   if (context && context->ft) {
     return context->ft->GetCustomOptionAt(context, index, name, valueType,value);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_ShouldProcess(MI_Context* context, const MI_Char *target, const MI_Char* action, MI_Boolean* flag) {
   if (context && context->ft) {
     return context->ft->ShouldProcess(context, target, action , flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_ShouldContinue(MI_Context* context, const MI_Char* message, MI_Boolean* flag) {
   if (context && context->ft) {
     return context->ft->ShouldContinue(context, message, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_PromptUser(MI_Context* context, const MI_Char* message, MI_PromptType promptType, MI_Boolean*flag ) {
   if (context && context->ft) {
     return context->ft->PromptUser(context, message, promptType, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteError(MI_Context* context, MI_Uint32 resultCode, const MI_Char* resultType, const MI_Char* errorMessage, MI_Boolean *flag) {
   if (context && context->ft) {
     return context->ft->WriteError(context, resultCode, resultType, errorMessage, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteCimError(MI_Context* context, const MI_Instance *error, MI_Boolean *flag) {
   if (context && context->ft) {
     return context->ft->WriteCimError(context, error, flag);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteMessage(MI_Context* context, MI_Uint32 channel, const MI_Char* message) {
   if (context && context->ft) {
     return context->ft->WriteMessage(context, channel, message);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteProgress(MI_Context* context, const MI_Char* activity, const MI_Char* currentOperation, const MI_Char* statusDescription, MI_Uint32 percentComplete, MI_Uint32 secondsRemaining) {
   if (context && context->ft) {
     return context->ft->WriteProgress(context, activity, currentOperation, statusDescription, percentComplete, secondsRemaining);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteStreamParameter(MI_Context* self, const MI_Char* name, const MI_Value* value, MI_Type type, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->WriteStreamParameter(self, name, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteWarning(MI_Context* context, const MI_Char* message) {
   if (context && context->ft) {
     return context->ft->WriteMessage(context, MI_WRITEMESSAGE_CHANNEL_WARNING, message);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteVerbose(MI_Context* context, const MI_Char* message) {
   if (context && context->ft) {
     return context->ft->WriteMessage(context, MI_WRITEMESSAGE_CHANNEL_VERBOSE, message);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Context_WriteDebug(MI_Context* context, const MI_Char* message) {
   if (context && context->ft) {
     return context->ft->WriteMessage(context, MI_WRITEMESSAGE_CHANNEL_DEBUG, message);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_InstanceOf(inst) (&(inst)->__instance)
 
 # pragma pack(pop)
 
 #endif /* _MI_h */
 
 #ifndef __MI_C_API_H
 #define __MI_C_API_H
 
 #ifndef MI_CALL_VERSION
 #define MI_CALL_VERSION 1
 #endif
 
 #if (MI_CALL_VERSION > 1)
 #error "Unsupported version of MI_CALL_VERSION. This SDK only supports version 1."
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef MI_Module* (MI_MAIN_CALL *MI_MainFunction)(MI_Server* server);
 
 typedef struct _MI_QualifierSet MI_QualifierSet;
 
 typedef struct _MI_QualifierSetFT {
   MI_Result (MI_CALL *GetQualifierCount)(const MI_QualifierSet *self, MI_Uint32 *count);
   MI_Result (MI_CALL *GetQualifierAt)(const MI_QualifierSet *self, MI_Uint32 index, const MI_Char **name, MI_Type *qualifierType, MI_Uint32 *qualifierFlags, MI_Value *qualifierValue);
   MI_Result (MI_CALL *GetQualifier)(const MI_QualifierSet *self, const MI_Char *name, MI_Type *qualifierType, MI_Uint32 *qualifierFlags, MI_Value *qualifierValue, MI_Uint32 *index);
 } MI_QualifierSetFT;
 
 struct _MI_QualifierSet {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_QualifierSetFT *ft;
 };
 
 typedef struct _MI_ParameterSet MI_ParameterSet;
 
 typedef struct _MI_ParameterSetFT {
   MI_Result (MI_CALL *GetMethodReturnType)(const MI_ParameterSet *self, MI_Type *returnType, MI_QualifierSet *qualifierSet);
   MI_Result (MI_CALL *GetParameterCount)(const MI_ParameterSet *self, MI_Uint32 *count);
   MI_Result (MI_CALL *GetParameterAt)(const MI_ParameterSet *self, MI_Uint32 index, const MI_Char **name, MI_Type *parameterType, MI_Char **referenceClass, MI_QualifierSet *qualifierSet);
   MI_Result (MI_CALL *GetParameter)(const MI_ParameterSet *self, const MI_Char *name, MI_Type *parameterType, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32 *index);
 } MI_ParameterSetFT;
 
 struct _MI_ParameterSet {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_ParameterSetFT * ft;
 };
 
 typedef struct _MI_ClassFT {
   MI_Result (MI_CALL *GetClassName)(const MI_Class* self, const MI_Char** className);
   MI_Result (MI_CALL *GetNameSpace)(const MI_Class* self, const MI_Char** nameSpace);
   MI_Result (MI_CALL *GetServerName)(const MI_Class* self, const MI_Char** serverName);
   MI_Result (MI_CALL *GetElementCount)(const MI_Class* self, MI_Uint32* count);
   MI_Result (MI_CALL *GetElement)(const MI_Class* self, const MI_Char* name, MI_Value* value, MI_Boolean* valueExists, MI_Type* type, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32* flags, MI_Uint32* index);
   MI_Result (MI_CALL *GetElementAt)(const MI_Class* self, MI_Uint32 index, const MI_Char** name, MI_Value* value, MI_Boolean* valueExists, MI_Type* type, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32* flags);
   MI_Result (MI_CALL *GetClassQualifierSet)(const MI_Class* self, MI_QualifierSet *qualifierSet);
   MI_Result (MI_CALL *GetMethodCount)(const MI_Class* self, MI_Uint32* count);
   MI_Result (MI_CALL *GetMethodAt)(const MI_Class *self, MI_Uint32 index, const MI_Char **name, MI_QualifierSet *qualifierSet, MI_ParameterSet *parameterSet);
   MI_Result (MI_CALL *GetMethod)(const MI_Class *self, const MI_Char *name, MI_QualifierSet *qualifierSet, MI_ParameterSet *parameterSet, MI_Uint32 *index);
   MI_Result (MI_CALL *GetParentClassName)(const MI_Class *self, const MI_Char **name);
   MI_Result (MI_CALL *GetParentClass)(const MI_Class *self, MI_Class **parentClass);
   MI_Result (MI_CALL *Delete)(MI_Class* self);
   MI_Result (MI_CALL *Clone)(const MI_Class* self, MI_Class** newClass);
 } MI_ClassFT;
 
 struct _MI_Class {
   const MI_ClassFT *ft;
   MI_CONST MI_ClassDecl *classDecl;
   MI_CONST MI_Char *namespaceName;
   MI_CONST MI_Char *serverName;
   ptrdiff_t reserved[4];
 };
 
 typedef struct _MI_Application MI_Application;
 typedef struct _MI_Session MI_Session;
 typedef struct _MI_Operation MI_Operation;
 typedef struct _MI_HostedProvider MI_HostedProvider;
 typedef struct _MI_DestinationOptions MI_DestinationOptions;
 typedef struct _MI_OperationOptions MI_OperationOptions;
 
 typedef enum _MI_OperationCallback_ResponseType {
   MI_OperationCallback_ResponseType_No,
   MI_OperationCallback_ResponseType_Yes,
   MI_OperationCallback_ResponseType_NoToAll,
   MI_OperationCallback_ResponseType_YesToAll
 } MI_OperationCallback_ResponseType;
 
 typedef void (MI_CALL *MI_OperationCallback_PromptUser)(MI_Operation *operation, void *callbackContext, const MI_Char *message, MI_PromptType promptType, MI_Result (MI_CALL * promptUserResult)(MI_Operation *operation, MI_OperationCallback_ResponseType response));
 typedef void (MI_CALL *MI_OperationCallback_WriteError)(MI_Operation *operation, void *callbackContext, MI_Instance*instance, MI_Result (MI_CALL * writeErrorResult)(MI_Operation *operation, MI_OperationCallback_ResponseType response));
 
 #define MI_WRITEMESSAGE_CHANNEL_WARNING 0
 #define MI_WRITEMESSAGE_CHANNEL_VERBOSE 1
 #define MI_WRITEMESSAGE_CHANNEL_DEBUG 2
 
 typedef void (MI_CALL *MI_OperationCallback_WriteMessage)(MI_Operation *operation, void *callbackContext, MI_Uint32 channel, const MI_Char *message);
 typedef void (MI_CALL *MI_OperationCallback_WriteProgress)(MI_Operation *operation, void *callbackContext, const MI_Char *activity, const MI_Char *currentOperation, const MI_Char *statusDescription, MI_Uint32 percentageComplete, MI_Uint32 secondsRemaining);
 typedef void (MI_CALL *MI_OperationCallback_Instance)(MI_Operation *operation, void *callbackContext, const MI_Instance *instance, MI_Boolean moreResults, MI_Result resultCode, const MI_Char *errorString, const MI_Instance *errorDetails, MI_Result (MI_CALL * resultAcknowledgement)(MI_Operation *operation));
 typedef void (MI_CALL *MI_OperationCallback_StreamedParameter)(MI_Operation *operation, void *callbackContext, const MI_Char *parameterName, MI_Type resultType, const MI_Value *result, MI_Result (MI_CALL * resultAcknowledgement)(MI_Operation *operation));
 typedef void (MI_CALL *MI_OperationCallback_Indication)(MI_Operation *operation, void *callbackContext, const MI_Instance *instance, const MI_Char *bookmark, const MI_Char *machineID, MI_Boolean moreResults, MI_Result resultCode, const MI_Char *errorString, const MI_Instance *errorDetails, MI_Result (MI_CALL * resultAcknowledgement)(MI_Operation *operation));
 typedef void (MI_CALL *MI_OperationCallback_Class)(MI_Operation *operation, void *callbackContext, const MI_Class *classResult, MI_Boolean moreResults, MI_Result resultCode, const MI_Char *errorString, const MI_Instance *errorDetails, MI_Result (MI_CALL * resultAcknowledgement)(MI_Operation *operation));
 
 typedef struct _MI_OperationCallbacks {
   void *callbackContext;
   MI_OperationCallback_PromptUser promptUser;
   MI_OperationCallback_WriteError writeError;
   MI_OperationCallback_WriteMessage writeMessage;
   MI_OperationCallback_WriteProgress writeProgress;
   MI_OperationCallback_Instance instanceResult;
   MI_OperationCallback_Indication indicationResult;
   MI_OperationCallback_Class classResult;
   MI_OperationCallback_StreamedParameter streamedParameterResult;
 } MI_OperationCallbacks;
 
 #define MI_OPERATIONCALLBACKS_NULL {NULL}
 
 typedef struct _MI_SessionCallbacks {
   void *callbackContext;
   void (MI_CALL *writeMessage)(MI_Application *application, void *callbackContext, MI_Uint32 channel, const MI_Char * message);
   void (MI_CALL *writeError)(MI_Application *application, void *callbackContext, MI_Instance *instance);
 } MI_SessionCallbacks;
 
 #define MI_SESSIONCALLBACKS_NULL {NULL}
 
 #define MI_OPERATIONFLAGS_AUTOMATIC_ACK_RESULTS 0x0000
 #define MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS 0x0001
 #define MI_OPERATIONFLAGS_NO_RTTI 0x0400
 #define MI_OPERATIONFLAGS_BASIC_RTTI 0x0002
 #define MI_OPERATIONFLAGS_STANDARD_RTTI 0x0800
 #define MI_OPERATIONFLAGS_FULL_RTTI 0x0004
 #define MI_OPERATIONFLAGS_DEFAULT_RTTI 0
 #define MI_OPERATIONFLAGS_NON_LOCALIZED_QUALIFIERS 0x0000
 #define MI_OPERATIONFLAGS_LOCALIZED_QUALIFIERS 0x0008
 #define MI_OPERATIONFLAGS_NON_EXPENSIVE_PROPERTIES_ONLY 0x0040
 #define MI_OPERATIONFLAGS_EXPENSIVE_PROPERTIES 0x0040
 #define MI_OPERATIONFLAGS_POLYMORPHISM_DEEP 0x0000
 #define MI_OPERATIONFLAGS_POLYMORPHISM_SHALLOW 0x0080
 #define MI_OPERATIONFLAGS_POLYMORPHISM_DEEP_BASE_PROPS_ONLY 0x0180
 #define MI_OPERATIONFLAGS_REPORT_OPERATION_STARTED 0x0200
 #define MI_AUTH_TYPE_DEFAULT MI_T("Default")
 #define MI_AUTH_TYPE_NONE MI_T("None")
 #define MI_AUTH_TYPE_DIGEST MI_T("Digest")
 #define MI_AUTH_TYPE_NEGO_WITH_CREDS MI_T("NegoWithCreds")
 #define MI_AUTH_TYPE_NEGO_NO_CREDS MI_T("NegoNoCreds")
 #define MI_AUTH_TYPE_BASIC MI_T("Basic")
 #define MI_AUTH_TYPE_KERBEROS MI_T("Kerberos")
 #define MI_AUTH_TYPE_CLIENT_CERTS MI_T("ClientCerts")
 #define MI_AUTH_TYPE_NTLM MI_T("Ntlmdomain")
 #if (WINVER >= 0x600)
 #define MI_AUTH_TYPE_CREDSSP MI_T("CredSSP")
 #endif
 #define MI_AUTH_TYPE_ISSUER_CERT MI_T("IssuerCert")
 
 typedef struct _MI_UsernamePasswordCreds {
   const MI_Char *domain;
   const MI_Char *username;
   const MI_Char *password;
 } MI_UsernamePasswordCreds;
 
 typedef struct _MI_UserCredentials {
   const MI_Char *authenticationType;
   union {
     MI_UsernamePasswordCreds usernamePassword;
     const MI_Char *certificateThumbprint;
   } credentials;
 } MI_UserCredentials;
 
 typedef enum _MI_SubscriptionDeliveryType {
   MI_SubscriptionDeliveryType_Pull = 1,
   MI_SubscriptionDeliveryType_Push = 2
 } MI_SubscriptionDeliveryType;
 
 typedef struct _MI_SubscriptionDeliveryOptions MI_SubscriptionDeliveryOptions;
 
 typedef struct _MI_SubscriptionDeliveryOptionsFT {
   MI_Result (MI_CALL *SetString)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, const MI_Char *value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetNumber)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, MI_Uint32 value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetDateTime)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, const MI_Datetime *value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetInterval)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, const MI_Interval *value, MI_Uint32 flags);
   MI_Result (MI_CALL *AddCredentials)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, const MI_UserCredentials *credentials, MI_Uint32 flags);
   MI_Result (MI_CALL *Delete)(MI_SubscriptionDeliveryOptions* self);
   MI_Result (MI_CALL *GetString)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, const MI_Char **value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetNumber)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, MI_Uint32 *value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetDateTime)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, MI_Datetime *value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetInterval)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, MI_Interval *value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOptionCount)(MI_SubscriptionDeliveryOptions *options, MI_Uint32 *count);
   MI_Result (MI_CALL *GetOptionAt)(MI_SubscriptionDeliveryOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOption)(MI_SubscriptionDeliveryOptions *options, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetCredentialsCount)(MI_SubscriptionDeliveryOptions *options, MI_Uint32 *count);
   MI_Result (MI_CALL *GetCredentialsAt)(MI_SubscriptionDeliveryOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_UserCredentials *credentials, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetCredentialsPasswordAt)(MI_SubscriptionDeliveryOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Char *password, MI_Uint32 bufferLength, MI_Uint32 *passwordLength, MI_Uint32 *flags);
   MI_Result (MI_CALL *Clone)(const MI_SubscriptionDeliveryOptions* self, MI_SubscriptionDeliveryOptions* newSubscriptionDeliveryOptions);
 } MI_SubscriptionDeliveryOptionsFT;
 
 typedef struct _MI_SubscriptionDeliveryOptions {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_SubscriptionDeliveryOptionsFT * ft;
 } MI_SubscriptionDeliveryOptions;
 
 #define MI_SUBSCRIPTIONDELIVERYOPTIONS_NULL { 0, 0, NULL }
 
 typedef struct _MI_Serializer MI_Serializer;
 typedef struct _MI_SerializerFT MI_SerializerFT;
 typedef struct _MI_Deserializer MI_Deserializer;
 typedef struct _MI_DeserializerFT MI_DeserializerFT;
 
 struct _MI_Serializer {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
 };
 
 struct _MI_Deserializer {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
 };
 
 struct _MI_SerializerFT {
   MI_Result (MI_CALL *Close)(MI_Serializer *serializer);
   MI_Result (MI_CALL *SerializeClass)(MI_Serializer *serializer, MI_Uint32 flags, const MI_Class *classObject, MI_Uint8 *clientBuffer, MI_Uint32 clientBufferLength, MI_Uint32 *clientBufferNeeded);
   MI_Result (MI_CALL *SerializeInstance)(MI_Serializer *serializer, MI_Uint32 flags, const MI_Instance *instanceObject, MI_Uint8 *clientBuffer, MI_Uint32 clientBufferLength, MI_Uint32 *clientBufferNeeded);
 };
 
 typedef MI_Result (MI_CALL *MI_Deserializer_ClassObjectNeeded)(void *context, const MI_Char *serverName, const MI_Char *namespaceName, const MI_Char *className, MI_Class **requestedClassObject);
 
 struct _MI_DeserializerFT {
   MI_Result (MI_CALL *Close)(MI_Deserializer *deserializer);
   MI_Result (MI_CALL *DeserializeClass)(MI_Deserializer *deserializer, MI_Uint32 flags, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Class *parentClass, const MI_Char *serverName, const MI_Char *namespaceName, MI_Deserializer_ClassObjectNeeded classObjectNeeded, void *classObjectNeededContext, MI_Uint32 *serializedBufferRead, MI_Class **classObject, MI_Instance **cimErrorDetails);
   MI_Result (MI_CALL *Class_GetClassName)(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *className, MI_Uint32 *classNameLength, MI_Instance **cimErrorDetails);
   MI_Result (MI_CALL *Class_GetParentClassName)(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *parentClassName, MI_Uint32 *parentClassNameLength, MI_Instance **cimErrorDetails);
   MI_Result (MI_CALL *DeserializeInstance)(MI_Deserializer *deserializer, MI_Uint32 flags, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Class **classObjects, MI_Uint32 numberClassObjects, MI_Deserializer_ClassObjectNeeded classObjectNeeded, void *classObjectNeededContext, MI_Uint32 *serializedBufferRead, MI_Instance **instanceObject, MI_Instance **cimErrorDetails);
   MI_Result (MI_CALL *Instance_GetClassName)(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *className, MI_Uint32 *classNameLength, MI_Instance **cimErrorDetails);
 };
 
 typedef struct _MI_ApplicationFT {
   MI_Result (MI_CALL *Close)(MI_Application *application);
   MI_Result (MI_CALL *NewSession)(MI_Application *application, const MI_Char *protocol, const MI_Char *destination, MI_DestinationOptions *options, MI_SessionCallbacks *callbacks, MI_Instance **extendedError, MI_Session *session);
   MI_Result (MI_CALL *NewHostedProvider)(MI_Application *application, const MI_Char *namespaceName, const MI_Char *providerName, MI_MainFunction mi_Main, MI_Instance **extendedError, MI_HostedProvider *provider);
   MI_Result (MI_CALL *NewInstance)(MI_Application *application, const MI_Char *className, const MI_ClassDecl *classRTTI, MI_Instance **instance);
   MI_Result (MI_CALL *NewDestinationOptions)(MI_Application *application, MI_DestinationOptions *options);
   MI_Result (MI_CALL *NewOperationOptions)(MI_Application *application, MI_Boolean customOptionsMustUnderstand, MI_OperationOptions *options);
   MI_Result (MI_CALL *NewSubscriptionDeliveryOptions)(MI_Application *application, MI_SubscriptionDeliveryType deliveryType, MI_SubscriptionDeliveryOptions *deliveryOptions);
   MI_Result (MI_CALL *NewSerializer)(MI_Application *application, MI_Uint32 flags, MI_Char *format, MI_Serializer *serializer);
   MI_Result (MI_CALL *NewDeserializer)(MI_Application *application, MI_Uint32 flags, MI_Char *format, MI_Deserializer *deserializer);
   MI_Result (MI_CALL *NewInstanceFromClass)(MI_Application *application, const MI_Char *className, const MI_Class *classObject, MI_Instance **instance);
   MI_Result (MI_CALL *NewClass)(MI_Application *application, const MI_ClassDecl* classDecl, const MI_Char *namespaceName, const MI_Char *serverName, MI_Class** classObject);
 } MI_ApplicationFT;
 
 typedef struct _MI_HostedProviderFT {
   MI_Result (MI_CALL *Close)(MI_HostedProvider *hostedProvider);
   MI_Result (MI_CALL *GetApplication)(MI_HostedProvider *hostedProvider, MI_Application *application);
 } MI_HostedProviderFT;
 
 typedef struct _MI_SessionFT {
   MI_Result (MI_CALL *Close)(MI_Session *session, void *completionContext, void (MI_CALL *completionCallback)(void *completionContext));
   MI_Result (MI_CALL *GetApplication)(MI_Session *session, MI_Application *application);
   void (MI_CALL *GetInstance)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *ModifyInstance)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *CreateInstance)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *DeleteInstance)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *Invoke)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, const MI_Char *methodName, const MI_Instance *inboundInstance, const MI_Instance *inboundProperties, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *EnumerateInstances)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *QueryInstances)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *queryDialect, const MI_Char *queryExpression, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *AssociatorInstances)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *instanceKeys, const MI_Char *assocClass, const MI_Char *resultClass, const MI_Char *role, const MI_Char *resultRole, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *ReferenceInstances)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *instanceKeys, const MI_Char *resultClass, const MI_Char *role, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *Subscribe)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *queryDialect, const MI_Char *queryExpression, const MI_SubscriptionDeliveryOptions *deliverOptions, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *GetClass)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *EnumerateClasses)(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_Boolean classNamesOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation);
   void (MI_CALL *TestConnection)(MI_Session *session, MI_Uint32 flags, MI_OperationCallbacks *callbacks, MI_Operation *operation);
 } MI_SessionFT;
 
 typedef struct _MI_OperationFT {
   MI_Result (MI_CALL *Close)(MI_Operation *operation);
   MI_Result (MI_CALL *Cancel)(MI_Operation *operation, MI_CancellationReason reason);
   MI_Result (MI_CALL *GetSession)(MI_Operation *operation, MI_Session *session);
   MI_Result (MI_CALL *GetInstance)(MI_Operation *operation, const MI_Instance **instance, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails);
   MI_Result (MI_CALL *GetIndication)(MI_Operation *operation, const MI_Instance **instance, const MI_Char **bookmark, const MI_Char **machineID, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails);
   MI_Result (MI_CALL *GetClass)(MI_Operation *operation, const MI_Class **classResult, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails);
 } MI_OperationFT;
 
 typedef struct _MI_DestinationOptionsFT {
   void (MI_CALL *Delete)(MI_DestinationOptions *options);
   MI_Result (MI_CALL *SetString)(MI_DestinationOptions *options, const MI_Char *optionName, const MI_Char *value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetNumber)(MI_DestinationOptions *options, const MI_Char *optionName, MI_Uint32 value, MI_Uint32 flags);
   MI_Result (MI_CALL *AddCredentials)(MI_DestinationOptions *options, const MI_Char *optionName, const MI_UserCredentials *credentials, MI_Uint32 flags);
   MI_Result (MI_CALL *GetString)(MI_DestinationOptions *options, const MI_Char *optionName, const MI_Char **value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetNumber)(MI_DestinationOptions *options, const MI_Char *optionName, MI_Uint32 *value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOptionCount)(MI_DestinationOptions *options, MI_Uint32 *count);
   MI_Result (MI_CALL *GetOptionAt)(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOption)(MI_DestinationOptions *options, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetCredentialsCount)(MI_DestinationOptions *options, MI_Uint32 *count);
   MI_Result (MI_CALL *GetCredentialsAt)(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_UserCredentials *credentials, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetCredentialsPasswordAt)(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Char *password, MI_Uint32 bufferLength, MI_Uint32 *passwordLength, MI_Uint32 *flags);
   MI_Result (MI_CALL *Clone)(const MI_DestinationOptions* self, MI_DestinationOptions* newDestinationOptions);
   MI_Result (MI_CALL *SetInterval)(MI_DestinationOptions *options, const MI_Char *optionName, const MI_Interval *value, MI_Uint32 flags);
   MI_Result (MI_CALL *GetInterval)(MI_DestinationOptions *options, const MI_Char *optionName, MI_Interval *value, MI_Uint32 *index, MI_Uint32 *flags);
 } MI_DestinationOptionsFT;
 
 typedef struct _MI_OperationOptionsFT {
   void (MI_CALL *Delete)(MI_OperationOptions *options);
   MI_Result (MI_CALL *SetString)(MI_OperationOptions *options, const MI_Char *optionName, const MI_Char *value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetNumber)(MI_OperationOptions *options, const MI_Char *optionName, MI_Uint32 value, MI_Uint32 flags);
   MI_Result (MI_CALL *SetCustomOption)(MI_OperationOptions *options, const MI_Char *optionName, MI_Type valueType, const MI_Value *value, MI_Boolean mustComply, MI_Uint32 flags);
   MI_Result (MI_CALL *GetString)(MI_OperationOptions *options, const MI_Char *optionName, const MI_Char **value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetNumber)(MI_OperationOptions *options, const MI_Char *optionName, MI_Uint32 *value, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOptionCount)(MI_OperationOptions *options, MI_Uint32 *count);
   MI_Result (MI_CALL *GetOptionAt)(MI_OperationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetOption)(MI_OperationOptions *options, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags);
   MI_Result (MI_CALL *GetEnabledChannels)(MI_OperationOptions *options, const MI_Char *optionName, MI_Uint32 *channels, MI_Uint32 bufferLength, MI_Uint32 *channelCount, MI_Uint32 *flags);
   MI_Result (MI_CALL *Clone)(const MI_OperationOptions* self, MI_OperationOptions* newOperationOptions);
   MI_Result (MI_CALL *SetInterval)(MI_OperationOptions *options, const MI_Char *optionName, const MI_Interval *value, MI_Uint32 flags);
   MI_Result (MI_CALL *GetInterval)(MI_OperationOptions *options, const MI_Char *optionName, MI_Interval *value, MI_Uint32 *index, MI_Uint32 *flags);
 } MI_OperationOptionsFT;
 
 struct _MI_Application {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_ApplicationFT *ft;
 };
 
 #define MI_APPLICATION_NULL { 0, 0, NULL }
 
 struct _MI_Session {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_SessionFT *ft;
 };
 
 #define MI_SESSION_NULL { 0, 0, NULL }
 
 struct _MI_Operation {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_OperationFT *ft;
 };
 
 #define MI_OPERATION_NULL { 0, 0, NULL }
 
 struct _MI_HostedProvider {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_HostedProviderFT *ft;
 };
 
 #define MI_HOSTEDPROVIDER_NULL { 0, 0, NULL }
 
 struct _MI_DestinationOptions {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_DestinationOptionsFT *ft;
 };
 
 #define MI_DESTINATIONOPTIONS_NULL { 0, 0, NULL }
 
 struct _MI_OperationOptions {
   MI_Uint64 reserved1;
   ptrdiff_t reserved2;
   const MI_OperationOptionsFT *ft;
 };
 
 #define MI_OPERATIONOPTIONS_NULL { 0, 0, NULL }
 
 typedef struct _MI_UtilitiesFT {
   MI_ErrorCategory (MI_CALL *MapErrorToMiErrorCategory)(MI_Char *errorType, MI_Uint32 error);
   MI_Result (MI_CALL *CimErrorFromErrorCode)(MI_Uint32 error, const MI_Char *errorType, const MI_Char* errorMessage, MI_Instance **cimError);
 } MI_UtilitiesFT;
 
 typedef struct _MI_ClientFT_V1 {
   const MI_ApplicationFT *applicationFT;
   const MI_SessionFT *sessionFT;
   const MI_OperationFT *operationFT;
   const MI_HostedProviderFT *hostedProviderFT;
   const MI_SerializerFT *serializerFT;
   const MI_DeserializerFT *deserializerFT;
   const MI_SubscriptionDeliveryOptionsFT *subscribeDeliveryOptionsFT;
   const MI_DestinationOptionsFT *destinationOptionsFT;
   const MI_OperationOptionsFT *operationOptionsFT;
   const MI_UtilitiesFT *utilitiesFT;
 } MI_ClientFT_V1;
 
 #ifndef _MANAGED_PURE
 __declspec(dllimport) const MI_ClientFT_V1 *mi_clientFT_V1;
 #endif
 
 #if (MI_CALL_VERSION == 1)
 #define mi_clientFT mi_clientFT_V1
 #endif
 
 MI_Result MI_MAIN_CALL MI_Application_InitializeV1(MI_Uint32 flags, const MI_Char *applicationID, MI_Instance **extendedError, MI_Application *application);
 
 #if MI_CALL_VERSION == 1
 #define MI_Application_Initialize MI_Application_InitializeV1
 #endif
 
 MI_INLINE MI_Result MI_Application_Close(MI_Application *application) {
   if (application && application->ft) {
     return application->ft->Close(application);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewInstance(MI_Application *application, const MI_Char *className, const MI_ClassDecl *classRTTI, MI_Instance **instance) {
   if (application && application->ft) {
     return application->ft->NewInstance(application, className, classRTTI, instance);
   } else {
     if (instance) {
       *instance = NULL;
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewInstanceFromClass(MI_Application *application, const MI_Char *className, const MI_Class *classObject, MI_Instance **instance) {
   if (application && application->ft) {
     return application->ft->NewInstanceFromClass(application, className, classObject, instance);
   } else {
     if (instance) {
       *instance = NULL;
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewClass(MI_Application *application, const MI_ClassDecl* classDecl, const MI_Char *namespaceName, const MI_Char *serverName, MI_Class** classObject) {
   if (application && application->ft) {
     return application->ft->NewClass(application, classDecl, namespaceName, serverName, classObject);
   } else {
     if (classObject) {
       *classObject = NULL;
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewParameterSet(MI_Application *application, const MI_ClassDecl *classRTTI, MI_Instance **instance) {
   if (application && application->ft) {
     return application->ft->NewInstance(application, MI_T("Parameters"), classRTTI, instance);
   } else {
     if (instance) {
       *instance = NULL;
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewDestinationOptions(MI_Application *application, MI_DestinationOptions *options) {
   if (application && application->ft) {
     return application->ft->NewDestinationOptions(application, options);
   } else {
     if (options) {
       memset(options, 0, sizeof(MI_DestinationOptions));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewOperationOptions(MI_Application *application, MI_Boolean mustUnderstand, MI_OperationOptions *options) {
   if (application && application->ft) {
     return application->ft->NewOperationOptions(application, mustUnderstand, options);
   } else {
     if (options) {
       memset(options, 0, sizeof(MI_OperationOptions));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewSubscriptionDeliveryOptions(MI_Application *application, MI_SubscriptionDeliveryType deliveryType, MI_SubscriptionDeliveryOptions *deliveryOptions) {
   if (application && application->ft) {
     return application->ft->NewSubscriptionDeliveryOptions(application, deliveryType, deliveryOptions);
   } else {
     if (deliveryOptions) {
       memset(deliveryOptions, 0, sizeof(MI_SubscriptionDeliveryOptions));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewSession(MI_Application *application, const MI_Char *protocol, const MI_Char *destination, MI_DestinationOptions *options, MI_SessionCallbacks *callbacks, MI_Instance **extendedError, MI_Session *session) {
   if (application && application->ft) {
     return application->ft->NewSession(application, protocol, destination, options, callbacks, extendedError, session);
   } else {
     if (session) {
       memset(session, 0, sizeof(MI_Session));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewHostedProvider(MI_Application *application, const MI_Char *namespaceName, const MI_Char *providerName, MI_MainFunction mi_Main, MI_Instance **extendedError, MI_HostedProvider *hostedProvider) {
   if (application && application->ft) {
     return application->ft->NewHostedProvider(application, namespaceName, providerName, mi_Main, extendedError, hostedProvider);
   } else {
     if (hostedProvider) {
       memset(hostedProvider, 0, sizeof(MI_HostedProvider));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewSerializer(MI_Application *application, MI_Uint32 flags, MI_Char *format, MI_Serializer *serializer) {
   if (application && application->ft) {
     return application->ft->NewSerializer(application, flags, format, serializer);
   } else {
     if (serializer) {
       memset(serializer, 0, sizeof(MI_Serializer));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Application_NewDeserializer(MI_Application *application, MI_Uint32 flags, MI_Char *format, MI_Deserializer *deserializer) {
   if (application && application->ft) {
     return application->ft->NewDeserializer(application, flags, format, deserializer);
   } else {
     if (deserializer) {
       memset(deserializer, 0, sizeof(MI_Deserializer));
     }
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_HostedProvider_Close(MI_HostedProvider *hostedProvider) {
   if (hostedProvider && hostedProvider->ft) {
     return hostedProvider->ft->Close(hostedProvider);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_HostedProvider_GetApplication(MI_HostedProvider *hostedProvider, MI_Application *application) {
   if (hostedProvider && hostedProvider->ft) {
     return hostedProvider->ft->GetApplication(hostedProvider, application);
   } else if (application) {
     memset(application, 0, sizeof(MI_Application));
   }
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Session_Close(MI_Session *session, void *completionContext, void (MI_CALL *completionCallback)(void *completionContext)) {
   if (session && session->ft) {
     return session->ft->Close(session, completionContext, completionCallback);
   } else if (completionCallback) {
     completionCallback(completionContext);
     return MI_RESULT_OK;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Session_GetApplication(MI_Session *session, MI_Application *application) {
   if (session && session->ft) {
     return session->ft->GetApplication(session, application);
   }
   if (application) {
     memset(application, 0, sizeof(MI_Application));
   }
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE void MI_Session_GetInstance(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->GetInstance(session, flags, options, namespaceName, inboundInstance, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_ModifyInstance(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->ModifyInstance(session, flags, options, namespaceName, inboundInstance, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_CreateInstance(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->CreateInstance(session, flags, options, namespaceName, inboundInstance, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_DeleteInstance(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *inboundInstance, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->DeleteInstance(session, flags, options, namespaceName, inboundInstance, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_Invoke(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, const MI_Char *methodName, const MI_Instance *inboundInstance, const MI_Instance *inboundProperties, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->Invoke(session, flags, options, namespaceName, className, methodName, inboundInstance, inboundProperties, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_EnumerateInstances(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->EnumerateInstances(session, flags, options, namespaceName, className, keysOnly, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_QueryInstances(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *queryDialect, const MI_Char *queryExpression, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->QueryInstances(session, flags, options, namespaceName, queryDialect, queryExpression, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_AssociatorInstances(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *instanceKey, const MI_Char *assocClass, const MI_Char *resultClass, const MI_Char *role, const MI_Char *resultRole, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->AssociatorInstances(session, flags, options, namespaceName, instanceKey, assocClass, resultClass, role, resultRole, keysOnly, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_ReferenceInstances(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Instance *instanceKey, const MI_Char *resultClass, const MI_Char *role, MI_Boolean keysOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->ReferenceInstances(session, flags, options, namespaceName, instanceKey, resultClass, role, keysOnly, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_Subscribe(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *queryDialect, const MI_Char *queryExpression, const MI_SubscriptionDeliveryOptions *deliverOptions, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->Subscribe(session, flags, options, namespaceName, queryDialect, queryExpression, deliverOptions, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->indicationResult) {
       callbacks->indicationResult(NULL, callbacks->callbackContext, NULL, NULL, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_GetClass(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->GetClass(session, flags, options, namespaceName, className, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->classResult) {
       callbacks->classResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_EnumerateClasses(MI_Session *session, MI_Uint32 flags, MI_OperationOptions *options, const MI_Char *namespaceName, const MI_Char *className, MI_Boolean classNamesOnly, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->EnumerateClasses(session, flags, options, namespaceName, className, classNamesOnly, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->classResult) {
       callbacks->classResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE void MI_Session_TestConnection(MI_Session *session, MI_Uint32 flags, MI_OperationCallbacks *callbacks, MI_Operation *operation) {
   if (session && session->ft) {
     session->ft->TestConnection(session, flags, callbacks, operation);
   } else {
     if (operation) {
       memset(operation, 0, sizeof(*operation));
     }
     if (callbacks && callbacks->instanceResult) {
       callbacks->instanceResult(NULL, callbacks->callbackContext, NULL, MI_FALSE, MI_RESULT_INVALID_PARAMETER, NULL, NULL, NULL);
     }
   }
 }
 
 MI_INLINE MI_Result MI_Operation_GetInstance(MI_Operation *operation, const MI_Instance **instance, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails) {
   if (operation && operation->ft) {
     return operation->ft->GetInstance(operation, instance, moreResults, result, errorMessage, completionDetails);
   }
   if (result)
     *result = MI_RESULT_INVALID_PARAMETER;
   if (moreResults)
     *moreResults = MI_FALSE;
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Operation_GetIndication(MI_Operation *operation, const MI_Instance **instance, const MI_Char **bookmark, const MI_Char **machineID, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails) {
   if (operation && operation->ft) {
     return operation->ft->GetIndication(operation, instance, bookmark, machineID, moreResults, result, errorMessage, completionDetails);
   }
   if (result)
     *result = MI_RESULT_INVALID_PARAMETER;
   if (moreResults)
     *moreResults = MI_FALSE;
   return  MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Operation_GetClass(MI_Operation *operation, const MI_Class **classResult, MI_Boolean *moreResults, MI_Result *result, const MI_Char **errorMessage, const MI_Instance **completionDetails) {
   if (operation && operation->ft) {
     return operation->ft->GetClass(operation, classResult, moreResults, result, errorMessage, completionDetails);
   }
   if (result)
     *result = MI_RESULT_INVALID_PARAMETER;
   if (moreResults)
     *moreResults = MI_FALSE;
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Operation_Close(MI_Operation *operation) {
   if (operation && operation->ft) {
     return operation->ft->Close(operation);
   }
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Operation_Cancel(MI_Operation *operation, MI_CancellationReason reason) {
   if (operation && operation->ft) {
     return operation->ft->Cancel(operation, reason);
   }
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE MI_Result MI_Operation_GetSession(MI_Operation *operation, MI_Session *session) {
   if (session) {
     memset(session, 0, sizeof(MI_Session));
   }
   if (operation && operation->ft) {
     return operation->ft->GetSession(operation, session);
   }
   return MI_RESULT_INVALID_PARAMETER;
 }
 
 MI_INLINE void MI_DestinationOptions_Delete(MI_DestinationOptions *options) {
   if (options && options->ft) {
     options->ft->Delete(options);
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetTimeout(MI_DestinationOptions *options, const MI_Interval *timeout) {
   if (options && options->ft) {
     return options->ft->SetInterval(options, MI_T("__MI_DESTINATIONOPTIONS_TIMEOUT"), timeout, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetTimeout(MI_DestinationOptions *options, MI_Interval *timeout) {
   if (options && options->ft) {
     return options->ft->GetInterval(options, MI_T("__MI_DESTINATIONOPTIONS_TIMEOUT"), timeout, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetCertCACheck(MI_DestinationOptions *options, MI_Boolean check) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_CA_CHECK"), check, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCertCACheck(MI_DestinationOptions *options, MI_Boolean *check) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_CA_CHECK"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *check = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetCertCNCheck(MI_DestinationOptions *options, MI_Boolean check) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_CN_CHECK"), check, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCertCNCheck(MI_DestinationOptions *options, MI_Boolean *check) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_CN_CHECK"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *check = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetCertRevocationCheck(MI_DestinationOptions *options, MI_Boolean check) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_REVOCATION_CHECK"), check, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCertRevocationCheck(MI_DestinationOptions *options, MI_Boolean *check) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_CERT_REVOCATION_CHECK"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *check = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetPacketPrivacy(MI_DestinationOptions *options, MI_Boolean privacy) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_PRIVACY"), privacy, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetPacketPrivacy(MI_DestinationOptions *options, MI_Boolean *privacy) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_PRIVACY"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *privacy = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetPacketIntegrity(MI_DestinationOptions *options, MI_Boolean integrity) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_INTEGRITY"), integrity, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetPacketIntegrity(MI_DestinationOptions *options, MI_Boolean *integrity) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_INTEGRITY"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *integrity = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_DESTINATIONOPTIONS_PACKET_ENCODING_DEFAULT MI_T("default")
 #define MI_DESTINATIONOPTIONS_PACKET_ENCODING_UTF8 MI_T("UTF8")
 #define MI_DESTINATIONOPTIONS_PACKET_ENCODING_UTF16 MI_T("UTF16")
 
 MI_INLINE MI_Result MI_DestinationOptions_SetPacketEncoding(MI_DestinationOptions *options, const MI_Char *encoding) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_ENCODING"), encoding, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetPacketEncoding(MI_DestinationOptions *options, const MI_Char **encoding) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_PACKET_ENCODING"), encoding, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetDataLocale(MI_DestinationOptions *options, const MI_Char *locale) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_DATA_LOCALE"), locale, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetDataLocale(MI_DestinationOptions *options, const MI_Char **locale) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_DATA_LOCALE"), locale, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetUILocale(MI_DestinationOptions *options, const MI_Char *locale) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_UI_LOCALE"), locale, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetUILocale(MI_DestinationOptions *options, const MI_Char **locale) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_UI_LOCALE"), locale, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetMaxEnvelopeSize(MI_DestinationOptions *options, MI_Uint32 sizeInKB) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_MAX_ENVELOPE_SIZE"), sizeInKB, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetMaxEnvelopeSize(MI_DestinationOptions *options, MI_Uint32 *sizeInKB) {
   if (options && options->ft) {
     return options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_MAX_ENVELOPE_SIZE"), sizeInKB, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetEncodePortInSPN(MI_DestinationOptions *options, MI_Boolean encodePort) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_ENCODE_PORT_IN_SPN"), encodePort, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetEncodePortInSPN(MI_DestinationOptions *options, MI_Boolean *encodePort) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_ENCODE_PORT_IN_SPN"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *encodePort = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetHttpUrlPrefix(MI_DestinationOptions *options, const MI_Char *prefix) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_HTTP_URL_PREFIX"), prefix, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetHttpUrlPrefix(MI_DestinationOptions *options, const MI_Char **prefix) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_HTTP_URL_PREFIX"), prefix, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetDestinationPort(MI_DestinationOptions *options, MI_Uint32 port) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_DESTINATION_PORT"), port, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetDestinationPort(MI_DestinationOptions *options, MI_Uint32 *port) {
   if (options && options->ft) {
     return options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_DESTINATION_PORT"), port, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_DESTINATIONOPTIONS_TRANSPORT_HTTP MI_T("HTTP")
 #define MI_DESTINATIONOPTIONS_TRANPSORT_HTTPS MI_T("HTTPS")
 
 MI_INLINE MI_Result MI_DestinationOptions_SetTransport(MI_DestinationOptions *options, const MI_Char *transport) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_TRANSPORT"), transport, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetTransport(MI_DestinationOptions *options, const MI_Char **transport) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_TRANSPORT"), transport, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_DESTINATIONOPTIONS_PROXY_TYPE_IE MI_T("IE")
 #define MI_DESTINATIONOPTIONS_PROXY_TYPE_WINHTTP MI_T("WinHTTP")
 #define MI_DESTINATIONOPTIONS_PROXY_TYPE_AUTO MI_T("Auto")
 #define MI_DESTINATIONOPTIONS_PROXY_TYPE_NONE MI_T("None")
 
 MI_INLINE MI_Result MI_DestinationOptions_SetProxyType(MI_DestinationOptions *options, const MI_Char *proxyType) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_DESTINATIONOPTIONS_PROXY_TYPE"), proxyType, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetProxyType(MI_DestinationOptions *options, const MI_Char **proxyType) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_DESTINATIONOPTIONS_PROXY_TYPE"), proxyType, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_AddProxyCredentials(MI_DestinationOptions *options, const MI_UserCredentials *credentials) {
   if (options && options->ft) {
     return options->ft->AddCredentials(options, MI_T("__MI_DESTINATIONOPTIONS_PROXY_CREDENTIALS"), credentials, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_AddDestinationCredentials(MI_DestinationOptions *options, const MI_UserCredentials *credentials) {
   if (options && options->ft) {
     return options->ft->AddCredentials(options, MI_T("__MI_DESTINATIONOPTIONS_DESTINATION_CREDENTIALS"), credentials, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 typedef enum _MI_DestinationOptions_ImpersonationType {
   MI_DestinationOptions_ImpersonationType_Default = 0,
   MI_DestinationOptions_ImpersonationType_None = 1,
   MI_DestinationOptions_ImpersonationType_Identify = 2,
   MI_DestinationOptions_ImpersonationType_Impersonate = 3,
   MI_DestinationOptions_ImpersonationType_Delegate = 4
 } MI_DestinationOptions_ImpersonationType;
 
 MI_INLINE MI_Result MI_DestinationOptions_SetImpersonationType(MI_DestinationOptions *options, MI_DestinationOptions_ImpersonationType impersonationType) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_IMPERSONATION_TYPE"), impersonationType, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetImpersonationType(MI_DestinationOptions *options, MI_DestinationOptions_ImpersonationType * impersonationType) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_DESTINATIONOPTIONS_IMPERSONATION_TYPE"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *impersonationType = (MI_DestinationOptions_ImpersonationType) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetString(MI_DestinationOptions *options, const MI_Char *optionName, const MI_Char *optionValue) {
   if (options && options->ft) {
     return options->ft->SetString(options, optionName, optionValue, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetString(MI_DestinationOptions *options, const MI_Char *optionName, const MI_Char **optionValue, MI_Uint32 *index) {
   if (options && options->ft) {
     return options->ft->GetString(options, optionName, optionValue, index, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_SetNumber(MI_DestinationOptions *options, const MI_Char *optionName, MI_Uint32 optionValue) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, optionName, optionValue, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetNumber(MI_DestinationOptions *options, const MI_Char *optionName, MI_Uint32 *optionValue, MI_Uint32 *index) {
   if (options && options->ft) {
     return options->ft->GetNumber(options, optionName, optionValue, index, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetOptionCount(MI_DestinationOptions *options, MI_Uint32 *count) {
   if (options && options->ft) {
     return options->ft->GetOptionCount(options, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetOptionAt(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetOptionAt(options, index, optionName, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetOption(MI_DestinationOptions *options, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetOption(options, optionName, value, type, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCredentialsCount(MI_DestinationOptions *options, MI_Uint32 *count) {
   if (options && options->ft) {
     return options->ft->GetCredentialsCount(options, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCredentialsAt(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_UserCredentials *credentials, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetCredentialsAt(options, index, optionName, credentials, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_DestinationOptions_GetCredentialsPasswordAt(MI_DestinationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Char *password, MI_Uint32 bufferLength, MI_Uint32 *passwordLength, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetCredentialsPasswordAt(options, index, optionName, password, bufferLength, passwordLength, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_DestinationOptions_Clone(const MI_DestinationOptions* self, MI_DestinationOptions* newDestinationOptions) {
   if (self && self->ft) {
     return self->ft->Clone(self, newDestinationOptions);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE void MI_OperationOptions_Delete(MI_OperationOptions *options) {
   if (options && options->ft) {
     options->ft->Delete(options);
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetWriteErrorMode(MI_OperationOptions *options, MI_CallbackMode mode) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_WRITEERRORMODE"), mode, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetWriteErrorMode(MI_OperationOptions *options, MI_CallbackMode *mode) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_WRITEERRORMODE"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *mode = (MI_CallbackMode) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetPromptUserMode(MI_OperationOptions *options, MI_CallbackMode mode) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODE"), mode, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetPromptUserMode(MI_OperationOptions *options, MI_CallbackMode *mode) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODE"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *mode = (MI_CallbackMode) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetPromptUserRegularMode(MI_OperationOptions *options, MI_CallbackMode mode, MI_Boolean ackValue) {
   if (options && options->ft) {
     MI_Result result = options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODE"), mode, 0);
     if( result == MI_RESULT_OK)
       return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODEREGULAR_ACKVALUE"), ackValue, 0);
     else
       return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetPromptUserRegularMode(MI_OperationOptions *options, MI_CallbackMode *mode, MI_Boolean *ackValue) {
   if (options && options->ft) {
     MI_Uint32 _mode;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODE"), &_mode, 0, 0);
     if( result == MI_RESULT_OK) {
       MI_Uint32 _ackValue;
       result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROMPTUSERMODEREGULAR_ACKVALUE"), &_ackValue, 0, 0);
       if( result == MI_RESULT_OK) {
         *mode = (MI_CallbackMode)_mode;
         *ackValue = (MI_Boolean) _ackValue;
       }
     }
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetProviderArchitecture(MI_OperationOptions *options, MI_ProviderArchitecture architecture, MI_Boolean mustComply) {
   if (options && options->ft) {
     MI_Result result = options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROVIDER_ARCHITECTURE"), architecture, 0);
     if(result == MI_RESULT_OK)
       return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_REQUIRED_ARCHITECTURE"), mustComply, 0);
     else
       return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetProviderArchitecture(MI_OperationOptions *options, MI_ProviderArchitecture *architecture, MI_Boolean *mustComply) {
   if (options && options->ft) {
     MI_Uint32 _architecture;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_PROVIDER_ARCHITECTURE"), &_architecture, 0, 0);
     if(result == MI_RESULT_OK) {
       MI_Uint32 _mustComply;
       result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_REQUIRED_ARCHITECTURE"), &_mustComply, 0, 0);
       if(result == MI_RESULT_OK) {
         *architecture = (MI_ProviderArchitecture)_architecture;
         *mustComply = (MI_Boolean)_mustComply;
       }
     }
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_EnableChannel(MI_OperationOptions *options, MI_Uint32 channel) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_CHANNEL"), channel, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_DisableChannel(MI_OperationOptions *options, MI_Uint32 channel) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_CHANNEL"), channel, 1);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetEnabledChannels(MI_OperationOptions *options, MI_Uint32 *channels, MI_Uint32 bufferLength, MI_Uint32 *channelCount, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetEnabledChannels(options, MI_T("__MI_OPERATIONOPTIONS_CHANNEL"), channels, bufferLength, channelCount, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetTimeout(MI_OperationOptions *options, const MI_Interval *timeout) {
   if (options && options->ft) {
     return options->ft->SetInterval(options, MI_T("__MI_OPERATIONOPTIONS_TIMEOUT"), timeout, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetTimeout(MI_OperationOptions *options, MI_Interval *timeout) {
   if (options && options->ft) {
     return options->ft->GetInterval(options, MI_T("__MI_OPERATIONOPTIONS_TIMEOUT"), timeout, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetResourceUriPrefix(MI_OperationOptions *options, const MI_Char *ruriPrefix) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_OPERATIONOPTIONS_RESOURCE_URI_PREFIX"), ruriPrefix, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetResourceUriPrefix(MI_OperationOptions *options, const MI_Char **ruriPrefix) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_OPERATIONOPTIONS_RESOURCE_URI_PREFIX"), ruriPrefix, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetResourceUri(MI_OperationOptions *options, const MI_Char *rUri) {
   if (options && options->ft) {
     return options->ft->SetString(options, MI_T("__MI_OPERATIONOPTIONS_RESOURCE_URI"), rUri, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetResourceUri(MI_OperationOptions *options, const MI_Char **rUri) {
   if (options && options->ft) {
     return options->ft->GetString(options, MI_T("__MI_OPERATIONOPTIONS_RESOURCE_URI"), rUri, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetUseMachineID(MI_OperationOptions *options, MI_Boolean machineID) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, MI_T("__MI_OPERATIONOPTIONS_USE_MACHINE_ID"), machineID, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetUseMachineID(MI_OperationOptions *options, MI_Boolean *machineID) {
   if (options && options->ft) {
     MI_Uint32 value;
     MI_Result result = options->ft->GetNumber(options, MI_T("__MI_OPERATIONOPTIONS_USE_MACHINE_ID"), &value, 0, 0);
     if (result == MI_RESULT_OK)
       *machineID = (MI_Boolean) value;
     return result;
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetCustomOption(MI_OperationOptions *options, const MI_Char *optionName, MI_Type optionValueType, const MI_Value *optionValue, MI_Boolean mustComply) {
   if (options && options->ft) {
     return options->ft->SetCustomOption(options, optionName, optionValueType, optionValue, mustComply, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetOptionCount(MI_OperationOptions *options, MI_Uint32 *count) {
   if (options && options->ft) {
     return options->ft->GetOptionCount(options, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetOptionAt(MI_OperationOptions *options, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetOptionAt(options, index, optionName, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetString(MI_OperationOptions *options, const MI_Char *optionName, const MI_Char *value, MI_Uint32 flags) {
   if (options && options->ft) {
     return options->ft->SetString(options, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetString(MI_OperationOptions *options, const MI_Char *optionName, const MI_Char **value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetString(options, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_SetNumber(MI_OperationOptions *options, const MI_Char *optionName, MI_Uint32 value, MI_Uint32 flags) {
   if (options && options->ft) {
     return options->ft->SetNumber(options, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetNumber(MI_OperationOptions *options, const MI_Char *optionName, MI_Uint32 *value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetNumber(options, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_OperationOptions_GetOption(MI_OperationOptions *options, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags) {
   if (options && options->ft) {
     return options->ft->GetOption(options, optionName, value, type, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_OperationOptions_Clone(const MI_OperationOptions* self, MI_OperationOptions* newOperationOptions) {
   if (self && self->ft) {
     return self->ft->Clone(self, newOperationOptions);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetClassName(const MI_Class* self, const MI_Char** className) {
   if (self && self->ft) {
     return self->ft->GetClassName(self, className);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetNameSpace(const MI_Class* self, const MI_Char** nameSpace) {
   if (self && self->ft) {
     return self->ft->GetNameSpace(self, nameSpace);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetServerName(const MI_Class* self, const MI_Char** serverName) {
   if (self && self->ft) {
     return self->ft->GetServerName(self, serverName);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetElementCount(const MI_Class* self, MI_Uint32* count) {
   if (self && self->ft) {
     return self->ft->GetElementCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetElement(const MI_Class* self, const MI_Char* name, MI_Value* value, MI_Boolean* valueExists, MI_Type* type, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32* flags, MI_Uint32* index) {
   if (self && self->ft) {
     return self->ft->GetElement(self, name, value, valueExists, type, referenceClass, qualifierSet, flags, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetElementAt(const MI_Class* self, MI_Uint32 index, const MI_Char** name, MI_Value* value, MI_Boolean* valueExists, MI_Type* type, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32* flags) {
   if (self && self->ft) {
     return self->ft->GetElementAt(self, index, name, value, valueExists, type, referenceClass, qualifierSet, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetClassQualifierSet(const MI_Class* self, MI_QualifierSet *qualifierSet) {
   if (self && self->ft) {
     return self->ft->GetClassQualifierSet(self, qualifierSet);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetMethodCount(const MI_Class* self, MI_Uint32* count) {
   if (self && self->ft) {
     return self->ft->GetMethodCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetMethodAt(const MI_Class *self, MI_Uint32 index, const MI_Char **name, MI_QualifierSet *qualifierSet, MI_ParameterSet *parameterSet) {
   if (self && self->ft) {
     return self->ft->GetMethodAt(self, index, name, qualifierSet, parameterSet);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetMethod(const MI_Class *self, const MI_Char *name, MI_QualifierSet *qualifierSet, MI_ParameterSet *parameterSet, MI_Uint32 *index) {
   if (self && self->ft) {
     return self->ft->GetMethod(self, name, qualifierSet, parameterSet, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetParentClassName(const MI_Class *self, const MI_Char **name) {
   if (self && self->ft) {
     return self->ft->GetParentClassName(self, name);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_GetParentClass(const MI_Class *self, MI_Class **parentClass) {
   if (self && self->ft) {
     return self->ft->GetParentClass(self, parentClass);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_Class_Delete(MI_Class* self) {
   if (self && self->ft) {
     return self->ft->Delete(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_Class_Clone(const MI_Class* self, MI_Class** newClass) {
   if (self && self->ft) {
     return self->ft->Clone(self, newClass);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_ParameterSet_GetMethodReturnType(const MI_ParameterSet *self, MI_Type *returnType, MI_QualifierSet *qualifierSet) {
   if (self && self->ft) {
     return self->ft->GetMethodReturnType(self, returnType, qualifierSet);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_ParameterSet_GetParameterCount(const MI_ParameterSet *self, MI_Uint32 *count) {
   if (self && self->ft) {
     return self->ft->GetParameterCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_ParameterSet_GetParameterAt(const MI_ParameterSet *self, MI_Uint32 index, const MI_Char **name, MI_Type *parameterType, MI_Char **referenceClass, MI_QualifierSet *qualifierSet) {
   if (self && self->ft) {
     return self->ft->GetParameterAt(self, index, name, parameterType, referenceClass, qualifierSet);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_ParameterSet_GetParameter(const MI_ParameterSet *self, const MI_Char *name, MI_Type *parameterType, MI_Char **referenceClass, MI_QualifierSet *qualifierSet, MI_Uint32 *index) {
   if (self && self->ft) {
     return self->ft->GetParameter(self, name, parameterType, referenceClass, qualifierSet, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_QualifierSet_GetQualifierCount(const MI_QualifierSet *self, MI_Uint32 *count) {
   if (self && self->ft) {
     return self->ft->GetQualifierCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_QualifierSet_GetQualifierAt(const MI_QualifierSet *self, MI_Uint32 index, const MI_Char **name, MI_Type *qualifierType, MI_Uint32 *qualifierFlags, MI_Value *qualifierValue) {
   if (self && self->ft) {
     return self->ft->GetQualifierAt(self, index, name, qualifierType, qualifierFlags, qualifierValue);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_QualifierSet_GetQualifier(const MI_QualifierSet *self, const MI_Char *name, MI_Type *qualifierType, MI_Uint32 *qualifierFlags, MI_Value *qualifierValue, MI_Uint32 *index) {
   if (self && self->ft) {
     return self->ft->GetQualifier(self, name, qualifierType, qualifierFlags, qualifierValue, index);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetMaximumLatency(MI_SubscriptionDeliveryOptions *self, MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->SetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_MAXIMUM_LATENCY"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetMaximumLatency(MI_SubscriptionDeliveryOptions *self, MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->GetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_MAXIMUM_LATENCY"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetHeartbeatInterval(MI_SubscriptionDeliveryOptions *self, MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->SetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_HEARTBEAT_INTERVAL"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetHeartbeatInterval(MI_SubscriptionDeliveryOptions *self, MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->GetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_HEARTBEAT_INTERVAL"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetExpirationTime(MI_SubscriptionDeliveryOptions *self, MI_Datetime *value) {
   if (self && self->ft) {
     return self->ft->SetDateTime(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_EXPIRATION_TIME"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetExpirationTime(MI_SubscriptionDeliveryOptions *self, MI_Datetime *value) {
   if (self && self->ft) {
     return self->ft->GetDateTime(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_EXPIRATION_TIME"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_SUBSCRIBE_BOOKMARK_OLDEST L"MI_SUBSCRIBE_BOOKMARK_OLDEST"
 #define MI_SUBSCRIBE_BOOKMARK_NEWEST L"MI_SUBSCRIBE_BOOKMARK_NEWEST"
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetBookmark(MI_SubscriptionDeliveryOptions *self, const MI_Char *value) {
   if (self && self->ft) {
     return self->ft->SetString(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_BOOKMARK"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetBookmark(MI_SubscriptionDeliveryOptions *self, const MI_Char **value) {
   if (self && self->ft) {
     return self->ft->GetString(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_BOOKMARK"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetDeliveryDestination(MI_SubscriptionDeliveryOptions *self, const MI_Char *value) {
   if (self && self->ft) {
     return self->ft->SetString(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_DESTINATION"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetDeliveryDestination(MI_SubscriptionDeliveryOptions *self, const MI_Char **value) {
   if (self && self->ft) {
     return self->ft->GetString(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_DESTINATION"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetDeliveryPortNumber(MI_SubscriptionDeliveryOptions *self, MI_Uint32 value) {
   if (self && self->ft) {
     return self->ft->SetNumber(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_PORT_NUMBER"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetDeliveryPortNumber(MI_SubscriptionDeliveryOptions *self, MI_Uint32 *value) {
   if (self && self->ft) {
     return self->ft->GetNumber(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_PORT_NUMBER"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_AddDeliveryCredentials(MI_SubscriptionDeliveryOptions *self, const MI_UserCredentials *value) {
   if (self && self->ft) {
     return self->ft->AddCredentials(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_ADD_DELIVERY_CREDENTIALS"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetDeliveryRetryInterval(MI_SubscriptionDeliveryOptions *self, const MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->SetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_RETRY_INTERVAL"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetDeliveryRetryInterval(MI_SubscriptionDeliveryOptions *self, MI_Interval *value) {
   if (self && self->ft) {
     return self->ft->GetInterval(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_RETRY_INTERVAL"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetDeliveryRetryAttempts(MI_SubscriptionDeliveryOptions *self, MI_Uint32 value) {
   if (self && self->ft) {
     return self->ft->SetNumber(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_RETRY_ATTEMPTS"), value, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetDeliveryRetryAttempts(MI_SubscriptionDeliveryOptions *self, MI_Uint32 *value) {
   if (self && self->ft) {
     return self->ft->GetNumber(self, MI_T("__MI_SUBSCRIPTIONDELIVERYOPTIONS_SET_DELIVERY_RETRY_ATTEMPTS"), value, 0, 0);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_Delete(MI_SubscriptionDeliveryOptions* self) {
   if (self && self->ft) {
     return self->ft->Delete(self);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetString(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, const MI_Char *value, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetString(self, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetNumber(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, MI_Uint32 value, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetNumber(self, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetDateTime(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, const MI_Datetime *value, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetDateTime(self, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_SetInterval(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, const MI_Interval *value, MI_Uint32 flags) {
   if (self && self->ft) {
     return self->ft->SetInterval(self, optionName, value, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetString(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, const MI_Char **value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetString(self, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetNumber(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, MI_Uint32 *value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetNumber(self, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetDateTime(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, MI_Datetime *value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetDateTime(self, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetInterval(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, MI_Interval *value, MI_Uint32 *index, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetInterval(self, optionName, value, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetOptionCount( MI_SubscriptionDeliveryOptions *self, MI_Uint32 *count) {
   if (self && self->ft) {
     return self->ft->GetOptionCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetOptionAt(MI_SubscriptionDeliveryOptions *self, MI_Uint32 index, const MI_Char **optionName, MI_Value *value, MI_Type *type, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetOptionAt(self, index, optionName, value, type, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetOption(MI_SubscriptionDeliveryOptions *self, const MI_Char *optionName, MI_Value *value, MI_Type *type, MI_Uint32 *index, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetOption(self, optionName, value, type, index, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetCredentialsCount(MI_SubscriptionDeliveryOptions *self, MI_Uint32 *count) {
   if (self && self->ft) {
     return self->ft->GetCredentialsCount(self, count);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetCredentialsAt(MI_SubscriptionDeliveryOptions *self, MI_Uint32 index, const MI_Char **optionName, MI_UserCredentials *credentials, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetCredentialsAt(self, index, optionName, credentials, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_SubscriptionDeliveryOptions_GetCredentialsPasswordAt(MI_SubscriptionDeliveryOptions *self, MI_Uint32 index, const MI_Char **optionName, MI_Char *password, MI_Uint32 bufferLength, MI_Uint32 *passwordLength, MI_Uint32 *flags) {
   if (self && self->ft) {
     return self->ft->GetCredentialsPasswordAt(self, index, optionName, password, bufferLength, passwordLength, flags);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 MI_INLINE MI_Result MI_INLINE_CALL MI_SubscriptionDeliveryOptions_Clone(const MI_SubscriptionDeliveryOptions* self, MI_SubscriptionDeliveryOptions* newSubscriptionDeliveryOptions) {
   if (self && self->ft) {
     return self->ft->Clone(self, newSubscriptionDeliveryOptions);
   } else {
     return MI_RESULT_INVALID_PARAMETER;
   }
 }
 
 #define MI_SERIALIZER_FLAGS_CLASS_DEEP 1
 #define MI_SERIALIZER_FLAGS_INSTANCE_WITH_CLASS 1
 
 MI_INLINE MI_Result MI_Serializer_Close(MI_Serializer *serializer) {
   return mi_clientFT->serializerFT->Close(serializer);
 }
 
 MI_INLINE MI_Result MI_Serializer_SerializeClass(MI_Serializer *serializer, MI_Uint32 flags, const MI_Class *classObject,  MI_Uint8 *clientBuffer, MI_Uint32 clientBufferLength,  MI_Uint32 *clientBufferNeeded) {
   return mi_clientFT->serializerFT->SerializeClass(serializer, flags, classObject, clientBuffer, clientBufferLength, clientBufferNeeded);
 }
 
 MI_INLINE MI_Result MI_Serializer_SerializeInstance(MI_Serializer *serializer, MI_Uint32 flags, const MI_Instance *instanceObject, MI_Uint8 *clientBuffer, MI_Uint32 clientBufferLength, MI_Uint32 *clientBufferNeeded) {
   return mi_clientFT->serializerFT->SerializeInstance(serializer, flags, instanceObject, clientBuffer, clientBufferLength, clientBufferNeeded);
 }
 
 MI_INLINE MI_Result MI_Deserializer_Close(MI_Deserializer *deserializer) {
   const MI_ClientFT_V1 *clientFT = mi_clientFT;
   const MI_DeserializerFT *deserializerFT = clientFT->deserializerFT;
   return deserializerFT->Close(deserializer);
 }
 
 MI_INLINE MI_Result MI_Deserializer_DeserializeClass(MI_Deserializer *deserializer, MI_Uint32 flags, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Class *parentClass, const MI_Char *serverName, const MI_Char *namespaceName, MI_Deserializer_ClassObjectNeeded classObjectNeeded, void *classObjectNeededContext, MI_Uint32 *serializedBufferRead, MI_Class **classObject, MI_Instance **cimErrorDetails) {
   return mi_clientFT->deserializerFT->DeserializeClass(deserializer, flags, serializedBuffer, serializedBufferLength, parentClass, serverName, namespaceName, classObjectNeeded, classObjectNeededContext, serializedBufferRead, classObject, cimErrorDetails);
 }
 
 MI_INLINE MI_Result MI_Deserializer_Class_GetClassName(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *className, MI_Uint32 *classNameLength, MI_Instance **cimErrorDetails) {
   return mi_clientFT->deserializerFT->Class_GetClassName(deserializer, serializedBuffer, serializedBufferLength, className, classNameLength, cimErrorDetails);
 }
 
 MI_INLINE MI_Result MI_Deserializer_Class_GetParentClassName(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *parentClassName, MI_Uint32 *parentClassNameLength, MI_Instance **cimErrorDetails) {
   return mi_clientFT->deserializerFT->Class_GetParentClassName(deserializer, serializedBuffer, serializedBufferLength, parentClassName, parentClassNameLength, cimErrorDetails);
 }
 
 MI_INLINE MI_Result MI_Deserializer_DeserializeInstance(MI_Deserializer *deserializer, MI_Uint32 flags, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Class **classObjects, MI_Uint32 numberClassObjects, MI_Deserializer_ClassObjectNeeded classObjectNeeded, void *classObjectNeededContext, MI_Uint32 *serializedBufferRead, MI_Instance **instanceObject, MI_Instance **cimErrorDetails) {
   return mi_clientFT->deserializerFT->DeserializeInstance(deserializer, flags, serializedBuffer, serializedBufferLength, classObjects, numberClassObjects, classObjectNeeded, classObjectNeededContext, serializedBufferRead, instanceObject, cimErrorDetails);
 }
 
 MI_INLINE MI_Result MI_Deserializer_Instance_GetClassName(MI_Deserializer *deserializer, MI_Uint8 *serializedBuffer, MI_Uint32 serializedBufferLength, MI_Char *className, MI_Uint32 *classNameLength, MI_Instance **cimErrorDetails) {
   return mi_clientFT->deserializerFT->Instance_GetClassName(deserializer, serializedBuffer, serializedBufferLength, className, classNameLength, cimErrorDetails);
 }
 
 MI_INLINE MI_ErrorCategory MI_Utilities_MapErrorToMiErrorCategory(MI_Char *errorType, MI_Uint32 error) {
   return mi_clientFT->utilitiesFT->MapErrorToMiErrorCategory(errorType, error);
 }
 
 MI_INLINE MI_Result MI_Utilities_CimErrorFromErrorCode(MI_Uint32 error, const MI_Char *errorType, const MI_Char* errorMessage, MI_Instance **cimError) {
   return mi_clientFT->utilitiesFT->CimErrorFromErrorCode(error, errorType, errorMessage, cimError);
 }
 
 #define MI_CancelationReason MI_CancellationReason
 #define _MI_CancelationReason _MI_CancellationReason
 #define MI_PostResult MI_Context_PostResult
 #define MI_PostCimError MI_Context_PostCimError
 #define MI_PostError MI_Context_PostError
 #define MI_PostInstance MI_Context_PostInstance
 #define MI_PostIndication MI_Context_PostIndication
 #define MI_ConstructInstance MI_Context_ConstructInstance
 #define MI_ConstructParameters MI_Context_ConstructParameters
 #define MI_NewInstance MI_Context_NewInstance
 #define MI_NewDynamicInstance MI_Context_NewDynamicInstance
 #define MI_NewParameters MI_Context_NewParameters
 #define MI_Canceled MI_Context_Canceled
 #define MI_GetLocale MI_Context_GetLocale
 #define MI_RegisterCancel MI_Context_RegisterCancel
 #define MI_RequestUnload MI_Context_RequestUnload
 #define MI_RefuseUnload MI_Context_RefuseUnload
 #define MI_GetLocalSession MI_Context_GetLocalSession
 #define MI_SetStringOption MI_Context_SetStringOption
 #define MI_GetStringOption MI_Context_GetStringOption
 #define MI_GetNumberOption MI_Context_GetNumberOption
 #define MI_GetCustomOption MI_Context_GetCustomOption
 #define MI_GetCustomOptionCount MI_Context_GetCustomOptionCount
 #define MI_GetCustomOptionAt MI_Context_GetCustomOptionAt
 #define MI_ShouldProcess MI_Context_ShouldProcess
 #define MI_ShouldContinue MI_Context_ShouldContinue
 #define MI_PromptUser MI_Context_PromptUser
 #define MI_WriteError MI_Context_WriteError
 #define MI_WriteCimError MI_Context_WriteCimError
 #define MI_WriteMessage MI_Context_WriteMessage
 #define MI_WriteProgress MI_Context_WriteProgress
 #define MI_WriteStreamParameter MI_Context_WriteStreamParameter
 #define MI_WriteWarning MI_Context_WriteWarning
 #define MI_WriteVerbose MI_Context_WriteVerbose
 #define MI_WriteDebug MI_Context_WriteDebug
 #define MI_SubscriptionDeliveryOptions__SetExpirationTime MI_SubscriptionDeliveryOptions_SetExpirationTime
 #define MI_SubscriptionDeliveryOptions__GetExpirationTime MI_SubscriptionDeliveryOptions_GetExpirationTime
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* __MI_C_API_H */
 
 #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */