//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (9)
//--------------------------------------------------------------------------------
pub const GUID_STRING_SIZE = @as(u32, 40);
pub const DATA_NOT_AVAILABLE = @as(u32, 4294967295);
pub const MTXDM_E_ENLISTRESOURCEFAILED = @as(u32, 2147803392);
pub const CRR_NO_REASON_SUPPLIED = @as(u32, 0);
pub const CRR_LIFETIME_LIMIT = @as(u32, 4294967295);
pub const CRR_ACTIVATION_LIMIT = @as(u32, 4294967294);
pub const CRR_CALL_LIMIT = @as(u32, 4294967293);
pub const CRR_MEMORY_LIMIT = @as(u32, 4294967292);
pub const CRR_RECYCLED_FROM_UI = @as(u32, 4294967291);

//--------------------------------------------------------------------------------
// Section: Types (211)
//--------------------------------------------------------------------------------
const CLSID_SecurityIdentity_Value = Guid.initString("ecabb0a5-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_SecurityIdentity = &CLSID_SecurityIdentity_Value;

const CLSID_SecurityCallers_Value = Guid.initString("ecabb0a6-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_SecurityCallers = &CLSID_SecurityCallers_Value;

const CLSID_SecurityCallContext_Value = Guid.initString("ecabb0a7-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_SecurityCallContext = &CLSID_SecurityCallContext_Value;

const CLSID_GetSecurityCallContextAppObject_Value = Guid.initString("ecabb0a8-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_GetSecurityCallContextAppObject = &CLSID_GetSecurityCallContextAppObject_Value;

const CLSID_Dummy30040732_Value = Guid.initString("ecabb0a9-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_Dummy30040732 = &CLSID_Dummy30040732_Value;

const CLSID_TransactionContext_Value = Guid.initString("7999fc25-d3c6-11cf-acab-00a024a55aef");
pub const CLSID_TransactionContext = &CLSID_TransactionContext_Value;

const CLSID_TransactionContextEx_Value = Guid.initString("5cb66670-d3d4-11cf-acab-00a024a55aef");
pub const CLSID_TransactionContextEx = &CLSID_TransactionContextEx_Value;

const CLSID_ByotServerEx_Value = Guid.initString("ecabb0aa-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_ByotServerEx = &CLSID_ByotServerEx_Value;

const CLSID_CServiceConfig_Value = Guid.initString("ecabb0c8-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_CServiceConfig = &CLSID_CServiceConfig_Value;

const CLSID_ServicePool_Value = Guid.initString("ecabb0c9-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_ServicePool = &CLSID_ServicePool_Value;

const CLSID_ServicePoolConfig_Value = Guid.initString("ecabb0ca-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_ServicePoolConfig = &CLSID_ServicePoolConfig_Value;

const CLSID_SharedProperty_Value = Guid.initString("2a005c05-a5de-11cf-9e66-00aa00a3f464");
pub const CLSID_SharedProperty = &CLSID_SharedProperty_Value;

const CLSID_SharedPropertyGroup_Value = Guid.initString("2a005c0b-a5de-11cf-9e66-00aa00a3f464");
pub const CLSID_SharedPropertyGroup = &CLSID_SharedPropertyGroup_Value;

const CLSID_SharedPropertyGroupManager_Value = Guid.initString("2a005c11-a5de-11cf-9e66-00aa00a3f464");
pub const CLSID_SharedPropertyGroupManager = &CLSID_SharedPropertyGroupManager_Value;

const CLSID_COMEvents_Value = Guid.initString("ecabb0ab-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_COMEvents = &CLSID_COMEvents_Value;

const CLSID_CoMTSLocator_Value = Guid.initString("ecabb0ac-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_CoMTSLocator = &CLSID_CoMTSLocator_Value;

const CLSID_MtsGrp_Value = Guid.initString("4b2e958d-0393-11d1-b1ab-00aa00ba3258");
pub const CLSID_MtsGrp = &CLSID_MtsGrp_Value;

const CLSID_ComServiceEvents_Value = Guid.initString("ecabb0c3-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_ComServiceEvents = &CLSID_ComServiceEvents_Value;

const CLSID_ComSystemAppEventData_Value = Guid.initString("ecabb0c6-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_ComSystemAppEventData = &CLSID_ComSystemAppEventData_Value;

const CLSID_CRMClerk_Value = Guid.initString("ecabb0bd-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_CRMClerk = &CLSID_CRMClerk_Value;

const CLSID_CRMRecoveryClerk_Value = Guid.initString("ecabb0be-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_CRMRecoveryClerk = &CLSID_CRMRecoveryClerk_Value;

const CLSID_LBEvents_Value = Guid.initString("ecabb0c1-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_LBEvents = &CLSID_LBEvents_Value;

const CLSID_MessageMover_Value = Guid.initString("ecabb0bf-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_MessageMover = &CLSID_MessageMover_Value;

const CLSID_DispenserManager_Value = Guid.initString("ecabb0c0-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_DispenserManager = &CLSID_DispenserManager_Value;

const CLSID_PoolMgr_Value = Guid.initString("ecabafb5-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_PoolMgr = &CLSID_PoolMgr_Value;

const CLSID_EventServer_Value = Guid.initString("ecabafbc-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_EventServer = &CLSID_EventServer_Value;

const CLSID_TrackerServer_Value = Guid.initString("ecabafb9-7f19-11d2-978e-0000f8757e2a");
pub const CLSID_TrackerServer = &CLSID_TrackerServer_Value;

const CLSID_AppDomainHelper_Value = Guid.initString("ef24f689-14f8-4d92-b4af-d7b1f0e70fd4");
pub const CLSID_AppDomainHelper = &CLSID_AppDomainHelper_Value;

const CLSID_ClrAssemblyLocator_Value = Guid.initString("458aa3b5-265a-4b75-bc05-9bea4630cf18");
pub const CLSID_ClrAssemblyLocator = &CLSID_ClrAssemblyLocator_Value;

const CLSID_COMAdminCatalog_Value = Guid.initString("f618c514-dfb8-11d1-a2cf-00805fc79235");
pub const CLSID_COMAdminCatalog = &CLSID_COMAdminCatalog_Value;

const CLSID_COMAdminCatalogObject_Value = Guid.initString("f618c515-dfb8-11d1-a2cf-00805fc79235");
pub const CLSID_COMAdminCatalogObject = &CLSID_COMAdminCatalogObject_Value;

const CLSID_COMAdminCatalogCollection_Value = Guid.initString("f618c516-dfb8-11d1-a2cf-00805fc79235");
pub const CLSID_COMAdminCatalogCollection = &CLSID_COMAdminCatalogCollection_Value;

// TODO: this type is limited to platform 'windows5.0'
const IID_ICOMAdminCatalog_Value = Guid.initString("dd662187-dfc2-11d1-a2cf-00805fc79235");
pub const IID_ICOMAdminCatalog = &IID_ICOMAdminCatalog_Value;
pub const ICOMAdminCatalog = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetCollection: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrCollName: ?BSTR,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrCollName: ?BSTR,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Connect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrCatalogServerName: ?BSTR,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrCatalogServerName: ?BSTR,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_MajorVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                plMajorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog,
                plMajorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_MinorVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                plMinorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog,
                plMinorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCollectionByQuery: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrCollName: ?BSTR,
                ppsaVarQuery: ?*?*SAFEARRAY,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrCollName: ?BSTR,
                ppsaVarQuery: ?*?*SAFEARRAY,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ImportComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrCLSIDOrProgID: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrCLSIDOrProgID: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrDLL: ?BSTR,
                bstrTLB: ?BSTR,
                bstrPSDLL: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrDLL: ?BSTR,
                bstrTLB: ?BSTR,
                bstrPSDLL: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ShutdownApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ExportApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrApplicationFile: ?BSTR,
                lOptions: COMAdminApplicationExportOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                bstrApplicationFile: ?BSTR,
                lOptions: COMAdminApplicationExportOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplicationFile: ?BSTR,
                bstrDestinationDirectory: ?BSTR,
                lOptions: COMAdminApplicationInstallOptions,
                bstrUserId: ?BSTR,
                bstrPassword: ?BSTR,
                bstrRSN: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplicationFile: ?BSTR,
                bstrDestinationDirectory: ?BSTR,
                lOptions: COMAdminApplicationInstallOptions,
                bstrUserId: ?BSTR,
                bstrPassword: ?BSTR,
                bstrRSN: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        StopRouter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RefreshRouter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        StartRouter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reserved1: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reserved2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallMultipleComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIDOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMultipleComponentsInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
                ppsaVarClassNames: ?*?*SAFEARRAY,
                ppsaVarFileFlags: ?*?*SAFEARRAY,
                ppsaVarComponentFlags: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
                ppsaVarClassNames: ?*?*SAFEARRAY,
                ppsaVarFileFlags: ?*?*SAFEARRAY,
                ppsaVarComponentFlags: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RefreshComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackupREGDB: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrBackupFilePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrBackupFilePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RestoreREGDB: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrBackupFilePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrBackupFilePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryApplicationFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplicationFile: ?BSTR,
                pbstrApplicationName: ?*?BSTR,
                pbstrApplicationDescription: ?*?BSTR,
                pbHasUsers: ?*i16,
                pbIsProxy: ?*i16,
                ppsaVarFileNames: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplicationFile: ?BSTR,
                pbstrApplicationName: ?*?BSTR,
                pbstrApplicationDescription: ?*?BSTR,
                pbHasUsers: ?*i16,
                pbIsProxy: ?*i16,
                ppsaVarFileNames: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        StartApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ServiceCheck: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                lService: i32,
                plStatus: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                lService: i32,
                plStatus: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallMultipleEventClasses: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDS: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                ppsaVarFileNames: ?*?*SAFEARRAY,
                ppsaVarCLSIDS: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallEventClass: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                bstrDLL: ?BSTR,
                bstrTLB: ?BSTR,
                bstrPSDLL: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrApplIdOrName: ?BSTR,
                bstrDLL: ?BSTR,
                bstrTLB: ?BSTR,
                bstrPSDLL: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventClassesForIID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog,
                bstrIID: ?BSTR,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
                ppsaVarProgIDs: ?*?*SAFEARRAY,
                ppsaVarDescriptions: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog,
                bstrIID: ?BSTR,
                ppsaVarCLSIDs: ?*?*SAFEARRAY,
                ppsaVarProgIDs: ?*?*SAFEARRAY,
                ppsaVarDescriptions: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_GetCollection(self: *const T, bstrCollName: ?BSTR, ppCatalogCollection: ?*?*IDispatch) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetCollection(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCollName, ppCatalogCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_Connect(self: *const T, bstrCatalogServerName: ?BSTR, ppCatalogCollection: ?*?*IDispatch) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Connect(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCatalogServerName, ppCatalogCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_get_MajorVersion(self: *const T, plMajorVersion: ?*i32) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).get_MajorVersion(@as(*const ICOMAdminCatalog, @ptrCast(self)), plMajorVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_get_MinorVersion(self: *const T, plMinorVersion: ?*i32) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).get_MinorVersion(@as(*const ICOMAdminCatalog, @ptrCast(self)), plMinorVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_GetCollectionByQuery(self: *const T, bstrCollName: ?BSTR, ppsaVarQuery: ?*?*SAFEARRAY, ppCatalogCollection: ?*?*IDispatch) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetCollectionByQuery(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCollName, ppsaVarQuery, ppCatalogCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_ImportComponent(self: *const T, bstrApplIDOrName: ?BSTR, bstrCLSIDOrProgID: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ImportComponent(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrCLSIDOrProgID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_InstallComponent(self: *const T, bstrApplIDOrName: ?BSTR, bstrDLL: ?BSTR, bstrTLB: ?BSTR, bstrPSDLL: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallComponent(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrDLL, bstrTLB, bstrPSDLL);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_ShutdownApplication(self: *const T, bstrApplIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ShutdownApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_ExportApplication(self: *const T, bstrApplIDOrName: ?BSTR, bstrApplicationFile: ?BSTR, lOptions: COMAdminApplicationExportOptions) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ExportApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrApplicationFile, lOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_InstallApplication(self: *const T, bstrApplicationFile: ?BSTR, bstrDestinationDirectory: ?BSTR, lOptions: COMAdminApplicationInstallOptions, bstrUserId: ?BSTR, bstrPassword: ?BSTR, bstrRSN: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplicationFile, bstrDestinationDirectory, lOptions, bstrUserId, bstrPassword, bstrRSN);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_StopRouter(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StopRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_RefreshRouter(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RefreshRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_StartRouter(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StartRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_Reserved1(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_Reserved2(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_InstallMultipleComponents(self: *const T, bstrApplIDOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDs: ?*?*SAFEARRAY) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallMultipleComponents(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, ppsaVarFileNames, ppsaVarCLSIDs);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_GetMultipleComponentsInfo(self: *const T, bstrApplIdOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDs: ?*?*SAFEARRAY, ppsaVarClassNames: ?*?*SAFEARRAY, ppsaVarFileFlags: ?*?*SAFEARRAY, ppsaVarComponentFlags: ?*?*SAFEARRAY) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetMultipleComponentsInfo(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, ppsaVarFileNames, ppsaVarCLSIDs, ppsaVarClassNames, ppsaVarFileFlags, ppsaVarComponentFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_RefreshComponents(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RefreshComponents(@as(*const ICOMAdminCatalog, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_BackupREGDB(self: *const T, bstrBackupFilePath: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).BackupREGDB(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrBackupFilePath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_RestoreREGDB(self: *const T, bstrBackupFilePath: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RestoreREGDB(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrBackupFilePath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_QueryApplicationFile(self: *const T, bstrApplicationFile: ?BSTR, pbstrApplicationName: ?*?BSTR, pbstrApplicationDescription: ?*?BSTR, pbHasUsers: ?*i16, pbIsProxy: ?*i16, ppsaVarFileNames: ?*?*SAFEARRAY) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).QueryApplicationFile(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplicationFile, pbstrApplicationName, pbstrApplicationDescription, pbHasUsers, pbIsProxy, ppsaVarFileNames);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_StartApplication(self: *const T, bstrApplIdOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StartApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_ServiceCheck(self: *const T, lService: i32, plStatus: ?*i32) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ServiceCheck(@as(*const ICOMAdminCatalog, @ptrCast(self)), lService, plStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_InstallMultipleEventClasses(self: *const T, bstrApplIdOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDS: ?*?*SAFEARRAY) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallMultipleEventClasses(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, ppsaVarFileNames, ppsaVarCLSIDS);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_InstallEventClass(self: *const T, bstrApplIdOrName: ?BSTR, bstrDLL: ?BSTR, bstrTLB: ?BSTR, bstrPSDLL: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallEventClass(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, bstrDLL, bstrTLB, bstrPSDLL);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog_GetEventClassesForIID(self: *const T, bstrIID: ?BSTR, ppsaVarCLSIDs: ?*?*SAFEARRAY, ppsaVarProgIDs: ?*?*SAFEARRAY, ppsaVarDescriptions: ?*?*SAFEARRAY) HRESULT {
                return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetEventClassesForIID(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrIID, ppsaVarCLSIDs, ppsaVarProgIDs, ppsaVarDescriptions);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const COMAdminInUse = enum(i32) {
    NotInUse = 0,
    InUseByCatalog = 1,
    InUseByRegistryUnknown = 2,
    InUseByRegistryProxyStub = 3,
    InUseByRegistryTypeLib = 4,
    InUseByRegistryClsid = 5,
};
pub const COMAdminNotInUse = COMAdminInUse.NotInUse;
pub const COMAdminInUseByCatalog = COMAdminInUse.InUseByCatalog;
pub const COMAdminInUseByRegistryUnknown = COMAdminInUse.InUseByRegistryUnknown;
pub const COMAdminInUseByRegistryProxyStub = COMAdminInUse.InUseByRegistryProxyStub;
pub const COMAdminInUseByRegistryTypeLib = COMAdminInUse.InUseByRegistryTypeLib;
pub const COMAdminInUseByRegistryClsid = COMAdminInUse.InUseByRegistryClsid;

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ICOMAdminCatalog2_Value = Guid.initString("790c6e0b-9194-4cc9-9426-a48a63185696");
pub const IID_ICOMAdminCatalog2 = &IID_ICOMAdminCatalog2_Value;
pub const ICOMAdminCatalog2 = extern struct {
    pub const VTable = extern struct {
        base: ICOMAdminCatalog.VTable,
        GetCollectionByQuery2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrCollectionName: ?BSTR,
                pVarQueryStrings: ?*VARIANT,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrCollectionName: ?BSTR,
                pVarQueryStrings: ?*VARIANT,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationInstanceIDFromProcessID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                lProcessID: i32,
                pbstrApplicationInstanceID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                lProcessID: i32,
                pbstrApplicationInstanceID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ShutdownApplicationInstances: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PauseApplicationInstances: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ResumeApplicationInstances: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RecycleApplicationInstances: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
                lReasonCode: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
                lReasonCode: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AreApplicationInstancesPaused: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
                pVarBoolPaused: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarApplicationInstanceID: ?*VARIANT,
                pVarBoolPaused: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DumpApplicationInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationInstanceID: ?BSTR,
                bstrDirectory: ?BSTR,
                lMaxImages: i32,
                pbstrDumpFile: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationInstanceID: ?BSTR,
                bstrDirectory: ?BSTR,
                lMaxImages: i32,
                pbstrDumpFile: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_IsApplicationInstanceDumpSupported: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pVarBoolDumpSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pVarBoolDumpSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateServiceForApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                bstrServiceName: ?BSTR,
                bstrStartType: ?BSTR,
                bstrErrorControl: ?BSTR,
                bstrDependencies: ?BSTR,
                bstrRunAs: ?BSTR,
                bstrPassword: ?BSTR,
                bDesktopOk: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                bstrServiceName: ?BSTR,
                bstrStartType: ?BSTR,
                bstrErrorControl: ?BSTR,
                bstrDependencies: ?BSTR,
                bstrRunAs: ?BSTR,
                bstrPassword: ?BSTR,
                bDesktopOk: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteServiceForApplication: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPartitionID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pbstrPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pbstrPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPartitionName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pbstrPartitionName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pbstrPartitionName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_CurrentPartition: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrPartitionIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrPartitionIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CurrentPartitionID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pbstrPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pbstrPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CurrentPartitionName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pbstrPartitionName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pbstrPartitionName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GlobalPartitionID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pbstrGlobalPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pbstrGlobalPartitionID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FlushPartitionCache: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyApplications: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrSourcePartitionIDOrName: ?BSTR,
                pVarApplicationID: ?*VARIANT,
                bstrDestinationPartitionIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrSourcePartitionIDOrName: ?BSTR,
                pVarApplicationID: ?*VARIANT,
                bstrDestinationPartitionIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrSourceApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                bstrDestinationApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrSourceApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                bstrDestinationApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrSourceApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                bstrDestinationApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrSourceApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                bstrDestinationApplicationIDOrName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AliasComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrSrcApplicationIDOrName: ?BSTR,
                bstrCLSIDOrProgID: ?BSTR,
                bstrDestApplicationIDOrName: ?BSTR,
                bstrNewProgId: ?BSTR,
                bstrNewClsid: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrSrcApplicationIDOrName: ?BSTR,
                bstrCLSIDOrProgID: ?BSTR,
                bstrDestApplicationIDOrName: ?BSTR,
                bstrNewProgId: ?BSTR,
                bstrNewClsid: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsSafeToDelete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrDllName: ?BSTR,
                pCOMAdminInUse: ?*COMAdminInUse,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrDllName: ?BSTR,
                pCOMAdminInUse: ?*COMAdminInUse,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ImportUnconfiguredComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PromoteUnconfiguredComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ImportComponents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationIDOrName: ?BSTR,
                pVarCLSIDOrProgID: ?*VARIANT,
                pVarComponentType: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Is64BitCatalogServer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                pbIs64Bit: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                pbIs64Bit: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ExportPartition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrPartitionIDOrName: ?BSTR,
                bstrPartitionFileName: ?BSTR,
                lOptions: COMAdminApplicationExportOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrPartitionIDOrName: ?BSTR,
                bstrPartitionFileName: ?BSTR,
                lOptions: COMAdminApplicationExportOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InstallPartition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrFileName: ?BSTR,
                bstrDestDirectory: ?BSTR,
                lOptions: COMAdminApplicationInstallOptions,
                bstrUserID: ?BSTR,
                bstrPassword: ?BSTR,
                bstrRSN: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrFileName: ?BSTR,
                bstrDestDirectory: ?BSTR,
                lOptions: COMAdminApplicationInstallOptions,
                bstrUserID: ?BSTR,
                bstrPassword: ?BSTR,
                bstrRSN: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryApplicationFile2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationFile: ?BSTR,
                ppFilesForImport: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrApplicationFile: ?BSTR,
                ppFilesForImport: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentVersionCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMAdminCatalog2,
                bstrCLSIDOrProgID: ?BSTR,
                plVersionCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMAdminCatalog2,
                bstrCLSIDOrProgID: ?BSTR,
                plVersionCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace ICOMAdminCatalog.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_GetCollectionByQuery2(self: *const T, bstrCollectionName: ?BSTR, pVarQueryStrings: ?*VARIANT, ppCatalogCollection: ?*?*IDispatch) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetCollectionByQuery2(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrCollectionName, pVarQueryStrings, ppCatalogCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_GetApplicationInstanceIDFromProcessID(self: *const T, lProcessID: i32, pbstrApplicationInstanceID: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceIDFromProcessID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), lProcessID, pbstrApplicationInstanceID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_ShutdownApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ShutdownApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_PauseApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).PauseApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_ResumeApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ResumeApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_RecycleApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT, lReasonCode: i32) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).RecycleApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID, lReasonCode);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_AreApplicationInstancesPaused(self: *const T, pVarApplicationInstanceID: ?*VARIANT, pVarBoolPaused: ?*i16) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).AreApplicationInstancesPaused(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID, pVarBoolPaused);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_DumpApplicationInstance(self: *const T, bstrApplicationInstanceID: ?BSTR, bstrDirectory: ?BSTR, lMaxImages: i32, pbstrDumpFile: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).DumpApplicationInstance(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationInstanceID, bstrDirectory, lMaxImages, pbstrDumpFile);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_get_IsApplicationInstanceDumpSupported(self: *const T, pVarBoolDumpSupported: ?*i16) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_IsApplicationInstanceDumpSupported(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarBoolDumpSupported);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_CreateServiceForApplication(self: *const T, bstrApplicationIDOrName: ?BSTR, bstrServiceName: ?BSTR, bstrStartType: ?BSTR, bstrErrorControl: ?BSTR, bstrDependencies: ?BSTR, bstrRunAs: ?BSTR, bstrPassword: ?BSTR, bDesktopOk: i16) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CreateServiceForApplication(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, bstrServiceName, bstrStartType, bstrErrorControl, bstrDependencies, bstrRunAs, bstrPassword, bDesktopOk);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_DeleteServiceForApplication(self: *const T, bstrApplicationIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).DeleteServiceForApplication(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_GetPartitionID(self: *const T, bstrApplicationIDOrName: ?BSTR, pbstrPartitionID: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pbstrPartitionID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_GetPartitionName(self: *const T, bstrApplicationIDOrName: ?BSTR, pbstrPartitionName: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetPartitionName(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pbstrPartitionName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_put_CurrentPartition(self: *const T, bstrPartitionIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).put_CurrentPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrPartitionIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_get_CurrentPartitionID(self: *const T, pbstrPartitionID: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_CurrentPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrPartitionID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_get_CurrentPartitionName(self: *const T, pbstrPartitionName: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_CurrentPartitionName(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrPartitionName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_get_GlobalPartitionID(self: *const T, pbstrGlobalPartitionID: ?*?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_GlobalPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrGlobalPartitionID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_FlushPartitionCache(self: *const T) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).FlushPartitionCache(@as(*const ICOMAdminCatalog2, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_CopyApplications(self: *const T, bstrSourcePartitionIDOrName: ?BSTR, pVarApplicationID: ?*VARIANT, bstrDestinationPartitionIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CopyApplications(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourcePartitionIDOrName, pVarApplicationID, bstrDestinationPartitionIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_CopyComponents(self: *const T, bstrSourceApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, bstrDestinationApplicationIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CopyComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourceApplicationIDOrName, pVarCLSIDOrProgID, bstrDestinationApplicationIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_MoveComponents(self: *const T, bstrSourceApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, bstrDestinationApplicationIDOrName: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).MoveComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourceApplicationIDOrName, pVarCLSIDOrProgID, bstrDestinationApplicationIDOrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_AliasComponent(self: *const T, bstrSrcApplicationIDOrName: ?BSTR, bstrCLSIDOrProgID: ?BSTR, bstrDestApplicationIDOrName: ?BSTR, bstrNewProgId: ?BSTR, bstrNewClsid: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).AliasComponent(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSrcApplicationIDOrName, bstrCLSIDOrProgID, bstrDestApplicationIDOrName, bstrNewProgId, bstrNewClsid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_IsSafeToDelete(self: *const T, bstrDllName: ?BSTR, pCOMAdminInUse: ?*COMAdminInUse) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).IsSafeToDelete(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrDllName, pCOMAdminInUse);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_ImportUnconfiguredComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ImportUnconfiguredComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_PromoteUnconfiguredComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).PromoteUnconfiguredComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_ImportComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ImportComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_get_Is64BitCatalogServer(self: *const T, pbIs64Bit: ?*i16) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_Is64BitCatalogServer(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbIs64Bit);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_ExportPartition(self: *const T, bstrPartitionIDOrName: ?BSTR, bstrPartitionFileName: ?BSTR, lOptions: COMAdminApplicationExportOptions) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ExportPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrPartitionIDOrName, bstrPartitionFileName, lOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_InstallPartition(self: *const T, bstrFileName: ?BSTR, bstrDestDirectory: ?BSTR, lOptions: COMAdminApplicationInstallOptions, bstrUserID: ?BSTR, bstrPassword: ?BSTR, bstrRSN: ?BSTR) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).InstallPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrFileName, bstrDestDirectory, lOptions, bstrUserID, bstrPassword, bstrRSN);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_QueryApplicationFile2(self: *const T, bstrApplicationFile: ?BSTR, ppFilesForImport: ?*?*IDispatch) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).QueryApplicationFile2(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationFile, ppFilesForImport);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMAdminCatalog2_GetComponentVersionCount(self: *const T, bstrCLSIDOrProgID: ?BSTR, plVersionCount: ?*i32) HRESULT {
                return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetComponentVersionCount(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrCLSIDOrProgID, plVersionCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICatalogObject_Value = Guid.initString("6eb22871-8a19-11d0-81b6-00a0c9231c29");
pub const IID_ICatalogObject = &IID_ICatalogObject_Value;
pub const ICatalogObject = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Value: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Value: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                val: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                val: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Key: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogObject,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogObject,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogObject,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogObject,
                pvarRetVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsPropertyReadOnly: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Valid: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogObject,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogObject,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsPropertyWriteOnly: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogObject,
                bstrPropName: ?BSTR,
                pbRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_get_Value(self: *const T, bstrPropName: ?BSTR, pvarRetVal: ?*VARIANT) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Value(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pvarRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_put_Value(self: *const T, bstrPropName: ?BSTR, val: VARIANT) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).put_Value(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, val);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_get_Key(self: *const T, pvarRetVal: ?*VARIANT) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Key(@as(*const ICatalogObject, @ptrCast(self)), pvarRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_get_Name(self: *const T, pvarRetVal: ?*VARIANT) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Name(@as(*const ICatalogObject, @ptrCast(self)), pvarRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_IsPropertyReadOnly(self: *const T, bstrPropName: ?BSTR, pbRetVal: ?*i16) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).IsPropertyReadOnly(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pbRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_get_Valid(self: *const T, pbRetVal: ?*i16) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Valid(@as(*const ICatalogObject, @ptrCast(self)), pbRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogObject_IsPropertyWriteOnly(self: *const T, bstrPropName: ?BSTR, pbRetVal: ?*i16) HRESULT {
                return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).IsPropertyWriteOnly(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pbRetVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICatalogCollection_Value = Guid.initString("6eb22872-8a19-11d0-81b6-00a0c9231c29");
pub const IID_ICatalogCollection = &IID_ICatalogCollection_Value;
pub const ICatalogCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                ppEnumVariant: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                ppEnumVariant: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                lIndex: i32,
                ppCatalogObject: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                lIndex: i32,
                ppCatalogObject: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                plObjectCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                plObjectCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Remove: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                lIndex: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                lIndex: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                ppCatalogObject: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                ppCatalogObject: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Populate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SaveChanges: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                pcChanges: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                pcChanges: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCollection: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                bstrCollName: ?BSTR,
                varObjectKey: VARIANT,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                bstrCollName: ?BSTR,
                varObjectKey: VARIANT,
                ppCatalogCollection: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                pVarNamel: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                pVarNamel: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AddEnabled: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                pVarBool: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                pVarBool: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RemoveEnabled: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                pVarBool: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                pVarBool: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetUtilInterface: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                ppIDispatch: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                ppIDispatch: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DataStoreMajorVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                plMajorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                plMajorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DataStoreMinorVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICatalogCollection,
                plMinorVersionl: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICatalogCollection,
                plMinorVersionl: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PopulateByKey: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                psaKeys: ?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                psaKeys: ?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PopulateByQuery: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICatalogCollection,
                bstrQueryString: ?BSTR,
                lQueryType: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICatalogCollection,
                bstrQueryString: ?BSTR,
                lQueryType: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get__NewEnum(self: *const T, ppEnumVariant: ?*?*IUnknown) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ICatalogCollection, @ptrCast(self)), ppEnumVariant);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_Item(self: *const T, lIndex: i32, ppCatalogObject: ?*?*IDispatch) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ICatalogCollection, @ptrCast(self)), lIndex, ppCatalogObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_Count(self: *const T, plObjectCount: ?*i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICatalogCollection, @ptrCast(self)), plObjectCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_Remove(self: *const T, lIndex: i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Remove(@as(*const ICatalogCollection, @ptrCast(self)), lIndex);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_Add(self: *const T, ppCatalogObject: ?*?*IDispatch) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const ICatalogCollection, @ptrCast(self)), ppCatalogObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_Populate(self: *const T) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Populate(@as(*const ICatalogCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_SaveChanges(self: *const T, pcChanges: ?*i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).SaveChanges(@as(*const ICatalogCollection, @ptrCast(self)), pcChanges);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_GetCollection(self: *const T, bstrCollName: ?BSTR, varObjectKey: VARIANT, ppCatalogCollection: ?*?*IDispatch) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).GetCollection(@as(*const ICatalogCollection, @ptrCast(self)), bstrCollName, varObjectKey, ppCatalogCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_Name(self: *const T, pVarNamel: ?*VARIANT) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Name(@as(*const ICatalogCollection, @ptrCast(self)), pVarNamel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_AddEnabled(self: *const T, pVarBool: ?*i16) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_AddEnabled(@as(*const ICatalogCollection, @ptrCast(self)), pVarBool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_RemoveEnabled(self: *const T, pVarBool: ?*i16) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_RemoveEnabled(@as(*const ICatalogCollection, @ptrCast(self)), pVarBool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_GetUtilInterface(self: *const T, ppIDispatch: ?*?*IDispatch) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).GetUtilInterface(@as(*const ICatalogCollection, @ptrCast(self)), ppIDispatch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_DataStoreMajorVersion(self: *const T, plMajorVersion: ?*i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_DataStoreMajorVersion(@as(*const ICatalogCollection, @ptrCast(self)), plMajorVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_get_DataStoreMinorVersion(self: *const T, plMinorVersionl: ?*i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_DataStoreMinorVersion(@as(*const ICatalogCollection, @ptrCast(self)), plMinorVersionl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_PopulateByKey(self: *const T, psaKeys: ?*SAFEARRAY) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).PopulateByKey(@as(*const ICatalogCollection, @ptrCast(self)), psaKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICatalogCollection_PopulateByQuery(self: *const T, bstrQueryString: ?BSTR, lQueryType: i32) HRESULT {
                return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).PopulateByQuery(@as(*const ICatalogCollection, @ptrCast(self)), bstrQueryString, lQueryType);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const COMAdminComponentType = enum(i32) {
    @"32BitComponent" = 1,
    @"64BitComponent" = 2,
};
pub const COMAdmin32BitComponent = COMAdminComponentType.@"32BitComponent";
pub const COMAdmin64BitComponent = COMAdminComponentType.@"64BitComponent";

pub const COMAdminApplicationInstallOptions = enum(i32) {
    NoUsers = 0,
    Users = 1,
    ForceOverwriteOfFiles = 2,
};
pub const COMAdminInstallNoUsers = COMAdminApplicationInstallOptions.NoUsers;
pub const COMAdminInstallUsers = COMAdminApplicationInstallOptions.Users;
pub const COMAdminInstallForceOverwriteOfFiles = COMAdminApplicationInstallOptions.ForceOverwriteOfFiles;

pub const COMAdminApplicationExportOptions = enum(i32) {
    NoUsers = 0,
    Users = 1,
    ApplicationProxy = 2,
    ForceOverwriteOfFiles = 4,
    In10Format = 16,
};
pub const COMAdminExportNoUsers = COMAdminApplicationExportOptions.NoUsers;
pub const COMAdminExportUsers = COMAdminApplicationExportOptions.Users;
pub const COMAdminExportApplicationProxy = COMAdminApplicationExportOptions.ApplicationProxy;
pub const COMAdminExportForceOverwriteOfFiles = COMAdminApplicationExportOptions.ForceOverwriteOfFiles;
pub const COMAdminExportIn10Format = COMAdminApplicationExportOptions.In10Format;

pub const COMAdminThreadingModels = enum(i32) {
    Apartment = 0,
    Free = 1,
    Main = 2,
    Both = 3,
    Neutral = 4,
    NotSpecified = 5,
};
pub const COMAdminThreadingModelApartment = COMAdminThreadingModels.Apartment;
pub const COMAdminThreadingModelFree = COMAdminThreadingModels.Free;
pub const COMAdminThreadingModelMain = COMAdminThreadingModels.Main;
pub const COMAdminThreadingModelBoth = COMAdminThreadingModels.Both;
pub const COMAdminThreadingModelNeutral = COMAdminThreadingModels.Neutral;
pub const COMAdminThreadingModelNotSpecified = COMAdminThreadingModels.NotSpecified;

pub const COMAdminTransactionOptions = enum(i32) {
    Ignored = 0,
    None = 1,
    Supported = 2,
    Required = 3,
    RequiresNew = 4,
};
pub const COMAdminTransactionIgnored = COMAdminTransactionOptions.Ignored;
pub const COMAdminTransactionNone = COMAdminTransactionOptions.None;
pub const COMAdminTransactionSupported = COMAdminTransactionOptions.Supported;
pub const COMAdminTransactionRequired = COMAdminTransactionOptions.Required;
pub const COMAdminTransactionRequiresNew = COMAdminTransactionOptions.RequiresNew;

pub const COMAdminTxIsolationLevelOptions = enum(i32) {
    Any = 0,
    ReadUnCommitted = 1,
    ReadCommitted = 2,
    RepeatableRead = 3,
    Serializable = 4,
};
pub const COMAdminTxIsolationLevelAny = COMAdminTxIsolationLevelOptions.Any;
pub const COMAdminTxIsolationLevelReadUnCommitted = COMAdminTxIsolationLevelOptions.ReadUnCommitted;
pub const COMAdminTxIsolationLevelReadCommitted = COMAdminTxIsolationLevelOptions.ReadCommitted;
pub const COMAdminTxIsolationLevelRepeatableRead = COMAdminTxIsolationLevelOptions.RepeatableRead;
pub const COMAdminTxIsolationLevelSerializable = COMAdminTxIsolationLevelOptions.Serializable;

pub const COMAdminSynchronizationOptions = enum(i32) {
    Ignored = 0,
    None = 1,
    Supported = 2,
    Required = 3,
    RequiresNew = 4,
};
pub const COMAdminSynchronizationIgnored = COMAdminSynchronizationOptions.Ignored;
pub const COMAdminSynchronizationNone = COMAdminSynchronizationOptions.None;
pub const COMAdminSynchronizationSupported = COMAdminSynchronizationOptions.Supported;
pub const COMAdminSynchronizationRequired = COMAdminSynchronizationOptions.Required;
pub const COMAdminSynchronizationRequiresNew = COMAdminSynchronizationOptions.RequiresNew;

pub const COMAdminActivationOptions = enum(i32) {
    Inproc = 0,
    Local = 1,
};
pub const COMAdminActivationInproc = COMAdminActivationOptions.Inproc;
pub const COMAdminActivationLocal = COMAdminActivationOptions.Local;

pub const COMAdminAccessChecksLevelOptions = enum(i32) {
    Level = 0,
    ComponentLevel = 1,
};
pub const COMAdminAccessChecksApplicationLevel = COMAdminAccessChecksLevelOptions.Level;
pub const COMAdminAccessChecksApplicationComponentLevel = COMAdminAccessChecksLevelOptions.ComponentLevel;

pub const COMAdminAuthenticationLevelOptions = enum(i32) {
    Default = 0,
    None = 1,
    Connect = 2,
    Call = 3,
    Packet = 4,
    Integrity = 5,
    Privacy = 6,
};
pub const COMAdminAuthenticationDefault = COMAdminAuthenticationLevelOptions.Default;
pub const COMAdminAuthenticationNone = COMAdminAuthenticationLevelOptions.None;
pub const COMAdminAuthenticationConnect = COMAdminAuthenticationLevelOptions.Connect;
pub const COMAdminAuthenticationCall = COMAdminAuthenticationLevelOptions.Call;
pub const COMAdminAuthenticationPacket = COMAdminAuthenticationLevelOptions.Packet;
pub const COMAdminAuthenticationIntegrity = COMAdminAuthenticationLevelOptions.Integrity;
pub const COMAdminAuthenticationPrivacy = COMAdminAuthenticationLevelOptions.Privacy;

pub const COMAdminImpersonationLevelOptions = enum(i32) {
    Anonymous = 1,
    Identify = 2,
    Impersonate = 3,
    Delegate = 4,
};
pub const COMAdminImpersonationAnonymous = COMAdminImpersonationLevelOptions.Anonymous;
pub const COMAdminImpersonationIdentify = COMAdminImpersonationLevelOptions.Identify;
pub const COMAdminImpersonationImpersonate = COMAdminImpersonationLevelOptions.Impersonate;
pub const COMAdminImpersonationDelegate = COMAdminImpersonationLevelOptions.Delegate;

pub const COMAdminAuthenticationCapabilitiesOptions = enum(i32) {
    None = 0,
    SecureReference = 2,
    StaticCloaking = 32,
    DynamicCloaking = 64,
};
pub const COMAdminAuthenticationCapabilitiesNone = COMAdminAuthenticationCapabilitiesOptions.None;
pub const COMAdminAuthenticationCapabilitiesSecureReference = COMAdminAuthenticationCapabilitiesOptions.SecureReference;
pub const COMAdminAuthenticationCapabilitiesStaticCloaking = COMAdminAuthenticationCapabilitiesOptions.StaticCloaking;
pub const COMAdminAuthenticationCapabilitiesDynamicCloaking = COMAdminAuthenticationCapabilitiesOptions.DynamicCloaking;

pub const COMAdminOS = enum(i32) {
    NotInitialized = 0,
    Windows3_1 = 1,
    Windows9x = 2,
    Windows2000 = 3,
    Windows2000AdvancedServer = 4,
    Windows2000Unknown = 5,
    Unknown = 6,
    WindowsXPPersonal = 11,
    WindowsXPProfessional = 12,
    WindowsNETStandardServer = 13,
    WindowsNETEnterpriseServer = 14,
    WindowsNETDatacenterServer = 15,
    WindowsNETWebServer = 16,
    WindowsLonghornPersonal = 17,
    WindowsLonghornProfessional = 18,
    WindowsLonghornStandardServer = 19,
    WindowsLonghornEnterpriseServer = 20,
    WindowsLonghornDatacenterServer = 21,
    WindowsLonghornWebServer = 22,
    Windows7Personal = 23,
    Windows7Professional = 24,
    Windows7StandardServer = 25,
    Windows7EnterpriseServer = 26,
    Windows7DatacenterServer = 27,
    Windows7WebServer = 28,
    Windows8Personal = 29,
    Windows8Professional = 30,
    Windows8StandardServer = 31,
    Windows8EnterpriseServer = 32,
    Windows8DatacenterServer = 33,
    Windows8WebServer = 34,
    WindowsBluePersonal = 35,
    WindowsBlueProfessional = 36,
    WindowsBlueStandardServer = 37,
    WindowsBlueEnterpriseServer = 38,
    WindowsBlueDatacenterServer = 39,
    WindowsBlueWebServer = 40,
};
pub const COMAdminOSNotInitialized = COMAdminOS.NotInitialized;
pub const COMAdminOSWindows3_1 = COMAdminOS.Windows3_1;
pub const COMAdminOSWindows9x = COMAdminOS.Windows9x;
pub const COMAdminOSWindows2000 = COMAdminOS.Windows2000;
pub const COMAdminOSWindows2000AdvancedServer = COMAdminOS.Windows2000AdvancedServer;
pub const COMAdminOSWindows2000Unknown = COMAdminOS.Windows2000Unknown;
pub const COMAdminOSUnknown = COMAdminOS.Unknown;
pub const COMAdminOSWindowsXPPersonal = COMAdminOS.WindowsXPPersonal;
pub const COMAdminOSWindowsXPProfessional = COMAdminOS.WindowsXPProfessional;
pub const COMAdminOSWindowsNETStandardServer = COMAdminOS.WindowsNETStandardServer;
pub const COMAdminOSWindowsNETEnterpriseServer = COMAdminOS.WindowsNETEnterpriseServer;
pub const COMAdminOSWindowsNETDatacenterServer = COMAdminOS.WindowsNETDatacenterServer;
pub const COMAdminOSWindowsNETWebServer = COMAdminOS.WindowsNETWebServer;
pub const COMAdminOSWindowsLonghornPersonal = COMAdminOS.WindowsLonghornPersonal;
pub const COMAdminOSWindowsLonghornProfessional = COMAdminOS.WindowsLonghornProfessional;
pub const COMAdminOSWindowsLonghornStandardServer = COMAdminOS.WindowsLonghornStandardServer;
pub const COMAdminOSWindowsLonghornEnterpriseServer = COMAdminOS.WindowsLonghornEnterpriseServer;
pub const COMAdminOSWindowsLonghornDatacenterServer = COMAdminOS.WindowsLonghornDatacenterServer;
pub const COMAdminOSWindowsLonghornWebServer = COMAdminOS.WindowsLonghornWebServer;
pub const COMAdminOSWindows7Personal = COMAdminOS.Windows7Personal;
pub const COMAdminOSWindows7Professional = COMAdminOS.Windows7Professional;
pub const COMAdminOSWindows7StandardServer = COMAdminOS.Windows7StandardServer;
pub const COMAdminOSWindows7EnterpriseServer = COMAdminOS.Windows7EnterpriseServer;
pub const COMAdminOSWindows7DatacenterServer = COMAdminOS.Windows7DatacenterServer;
pub const COMAdminOSWindows7WebServer = COMAdminOS.Windows7WebServer;
pub const COMAdminOSWindows8Personal = COMAdminOS.Windows8Personal;
pub const COMAdminOSWindows8Professional = COMAdminOS.Windows8Professional;
pub const COMAdminOSWindows8StandardServer = COMAdminOS.Windows8StandardServer;
pub const COMAdminOSWindows8EnterpriseServer = COMAdminOS.Windows8EnterpriseServer;
pub const COMAdminOSWindows8DatacenterServer = COMAdminOS.Windows8DatacenterServer;
pub const COMAdminOSWindows8WebServer = COMAdminOS.Windows8WebServer;
pub const COMAdminOSWindowsBluePersonal = COMAdminOS.WindowsBluePersonal;
pub const COMAdminOSWindowsBlueProfessional = COMAdminOS.WindowsBlueProfessional;
pub const COMAdminOSWindowsBlueStandardServer = COMAdminOS.WindowsBlueStandardServer;
pub const COMAdminOSWindowsBlueEnterpriseServer = COMAdminOS.WindowsBlueEnterpriseServer;
pub const COMAdminOSWindowsBlueDatacenterServer = COMAdminOS.WindowsBlueDatacenterServer;
pub const COMAdminOSWindowsBlueWebServer = COMAdminOS.WindowsBlueWebServer;

pub const COMAdminServiceOptions = enum(i32) {
    r = 1,
};
pub const COMAdminServiceLoadBalanceRouter = COMAdminServiceOptions.r;

pub const COMAdminServiceStatusOptions = enum(i32) {
    Stopped = 0,
    StartPending = 1,
    StopPending = 2,
    Running = 3,
    ContinuePending = 4,
    PausePending = 5,
    Paused = 6,
    UnknownState = 7,
};
pub const COMAdminServiceStopped = COMAdminServiceStatusOptions.Stopped;
pub const COMAdminServiceStartPending = COMAdminServiceStatusOptions.StartPending;
pub const COMAdminServiceStopPending = COMAdminServiceStatusOptions.StopPending;
pub const COMAdminServiceRunning = COMAdminServiceStatusOptions.Running;
pub const COMAdminServiceContinuePending = COMAdminServiceStatusOptions.ContinuePending;
pub const COMAdminServicePausePending = COMAdminServiceStatusOptions.PausePending;
pub const COMAdminServicePaused = COMAdminServiceStatusOptions.Paused;
pub const COMAdminServiceUnknownState = COMAdminServiceStatusOptions.UnknownState;

pub const COMAdminQCMessageAuthenticateOptions = enum(i32) {
    SecureApps = 0,
    Off = 1,
    On = 2,
};
pub const COMAdminQCMessageAuthenticateSecureApps = COMAdminQCMessageAuthenticateOptions.SecureApps;
pub const COMAdminQCMessageAuthenticateOff = COMAdminQCMessageAuthenticateOptions.Off;
pub const COMAdminQCMessageAuthenticateOn = COMAdminQCMessageAuthenticateOptions.On;

pub const COMAdminFileFlags = enum(i32) {
    Loadable = 1,
    COM = 2,
    ContainsPS = 4,
    ContainsComp = 8,
    ContainsTLB = 16,
    SelfReg = 32,
    SelfUnReg = 64,
    UnloadableDLL = 128,
    DoesNotExist = 256,
    AlreadyInstalled = 512,
    BadTLB = 1024,
    GetClassObjFailed = 2048,
    ClassNotAvailable = 4096,
    Registrar = 8192,
    NoRegistrar = 16384,
    DLLRegsvrFailed = 32768,
    RegTLBFailed = 65536,
    RegistrarFailed = 131072,
    Error = 262144,
};
pub const COMAdminFileFlagLoadable = COMAdminFileFlags.Loadable;
pub const COMAdminFileFlagCOM = COMAdminFileFlags.COM;
pub const COMAdminFileFlagContainsPS = COMAdminFileFlags.ContainsPS;
pub const COMAdminFileFlagContainsComp = COMAdminFileFlags.ContainsComp;
pub const COMAdminFileFlagContainsTLB = COMAdminFileFlags.ContainsTLB;
pub const COMAdminFileFlagSelfReg = COMAdminFileFlags.SelfReg;
pub const COMAdminFileFlagSelfUnReg = COMAdminFileFlags.SelfUnReg;
pub const COMAdminFileFlagUnloadableDLL = COMAdminFileFlags.UnloadableDLL;
pub const COMAdminFileFlagDoesNotExist = COMAdminFileFlags.DoesNotExist;
pub const COMAdminFileFlagAlreadyInstalled = COMAdminFileFlags.AlreadyInstalled;
pub const COMAdminFileFlagBadTLB = COMAdminFileFlags.BadTLB;
pub const COMAdminFileFlagGetClassObjFailed = COMAdminFileFlags.GetClassObjFailed;
pub const COMAdminFileFlagClassNotAvailable = COMAdminFileFlags.ClassNotAvailable;
pub const COMAdminFileFlagRegistrar = COMAdminFileFlags.Registrar;
pub const COMAdminFileFlagNoRegistrar = COMAdminFileFlags.NoRegistrar;
pub const COMAdminFileFlagDLLRegsvrFailed = COMAdminFileFlags.DLLRegsvrFailed;
pub const COMAdminFileFlagRegTLBFailed = COMAdminFileFlags.RegTLBFailed;
pub const COMAdminFileFlagRegistrarFailed = COMAdminFileFlags.RegistrarFailed;
pub const COMAdminFileFlagError = COMAdminFileFlags.Error;

pub const COMAdminComponentFlags = enum(i32) {
    TypeInfoFound = 1,
    COMPlusPropertiesFound = 2,
    ProxyFound = 4,
    InterfacesFound = 8,
    AlreadyInstalled = 16,
    NotInApplication = 32,
};
pub const COMAdminCompFlagTypeInfoFound = COMAdminComponentFlags.TypeInfoFound;
pub const COMAdminCompFlagCOMPlusPropertiesFound = COMAdminComponentFlags.COMPlusPropertiesFound;
pub const COMAdminCompFlagProxyFound = COMAdminComponentFlags.ProxyFound;
pub const COMAdminCompFlagInterfacesFound = COMAdminComponentFlags.InterfacesFound;
pub const COMAdminCompFlagAlreadyInstalled = COMAdminComponentFlags.AlreadyInstalled;
pub const COMAdminCompFlagNotInApplication = COMAdminComponentFlags.NotInApplication;

pub const COMAdminErrorCodes = enum(i32) {
    ObjectErrors = -2146368511,
    ObjectInvalid = -2146368510,
    KeyMissing = -2146368509,
    AlreadyInstalled = -2146368508,
    AppFileWriteFail = -2146368505,
    AppFileReadFail = -2146368504,
    AppFileVersion = -2146368503,
    BadPath = -2146368502,
    ApplicationExists = -2146368501,
    RoleExists = -2146368500,
    CantCopyFile = -2146368499,
    NoUser = -2146368497,
    InvalidUserids = -2146368496,
    NoRegistryCLSID = -2146368495,
    BadRegistryProgID = -2146368494,
    AuthenticationLevel = -2146368493,
    UserPasswdNotValid = -2146368492,
    CLSIDOrIIDMismatch = -2146368488,
    RemoteInterface = -2146368487,
    DllRegisterServer = -2146368486,
    NoServerShare = -2146368485,
    DllLoadFailed = -2146368483,
    BadRegistryLibID = -2146368482,
    AppDirNotFound = -2146368481,
    RegistrarFailed = -2146368477,
    CompFileDoesNotExist = -2146368476,
    CompFileLoadDLLFail = -2146368475,
    CompFileGetClassObj = -2146368474,
    CompFileClassNotAvail = -2146368473,
    CompFileBadTLB = -2146368472,
    CompFileNotInstallable = -2146368471,
    NotChangeable = -2146368470,
    NotDeletable = -2146368469,
    Session = -2146368468,
    CompMoveLocked = -2146368467,
    CompMoveBadDest = -2146368466,
    RegisterTLB = -2146368464,
    SystemApp = -2146368461,
    CompFileNoRegistrar = -2146368460,
    CoReqCompInstalled = -2146368459,
    ServiceNotInstalled = -2146368458,
    PropertySaveFailed = -2146368457,
    ObjectExists = -2146368456,
    ComponentExists = -2146368455,
    RegFileCorrupt = -2146368453,
    PropertyOverflow = -2146368452,
    NotInRegistry = -2146368450,
    ObjectNotPoolable = -2146368449,
    ApplidMatchesClsid = -2146368442,
    RoleDoesNotExist = -2146368441,
    StartAppNeedsComponents = -2146368440,
    RequiresDifferentPlatform = -2146368439,
    QueuingServiceNotAvailable = -2146367998,
    ObjectParentMissing = -2146367480,
    ObjectDoesNotExist = -2146367479,
    CanNotExportAppProxy = -2146368438,
    CanNotStartApp = -2146368437,
    CanNotExportSystemApp = -2146368436,
    CanNotSubscribeToComponent = -2146368435,
    AppNotRunning = -2146367478,
    EventClassCannotBeSubscriber = -2146368434,
    LibAppProxyIncompatible = -2146368433,
    BasePartitionOnly = -2146368432,
    DuplicatePartitionName = -2146368425,
    PartitionInUse = -2146368423,
    ImportedComponentsNotAllowed = -2146368421,
    RegdbNotInitialized = -2146368398,
    RegdbNotOpen = -2146368397,
    RegdbSystemErr = -2146368396,
    RegdbAlreadyRunning = -2146368395,
    MigVersionNotSupported = -2146368384,
    MigSchemaNotFound = -2146368383,
    CatBitnessMismatch = -2146368382,
    CatUnacceptableBitness = -2146368381,
    CatWrongAppBitnessBitness = -2146368380,
    CatPauseResumeNotSupported = -2146368379,
    CatServerFault = -2146368378,
    CantRecycleLibraryApps = -2146367473,
    CantRecycleServiceApps = -2146367471,
    ProcessAlreadyRecycled = -2146367470,
    PausedProcessMayNotBeRecycled = -2146367469,
    InvalidPartition = -2146367477,
    PartitionMsiOnly = -2146367463,
    StartAppDisabled = -2146368431,
    CompMoveSource = -2146367460,
    CompMoveDest = -2146367459,
    CompMovePrivate = -2146367458,
    CannotCopyEventClass = -2146367456,
};
pub const COMAdminErrObjectErrors = COMAdminErrorCodes.ObjectErrors;
pub const COMAdminErrObjectInvalid = COMAdminErrorCodes.ObjectInvalid;
pub const COMAdminErrKeyMissing = COMAdminErrorCodes.KeyMissing;
pub const COMAdminErrAlreadyInstalled = COMAdminErrorCodes.AlreadyInstalled;
pub const COMAdminErrAppFileWriteFail = COMAdminErrorCodes.AppFileWriteFail;
pub const COMAdminErrAppFileReadFail = COMAdminErrorCodes.AppFileReadFail;
pub const COMAdminErrAppFileVersion = COMAdminErrorCodes.AppFileVersion;
pub const COMAdminErrBadPath = COMAdminErrorCodes.BadPath;
pub const COMAdminErrApplicationExists = COMAdminErrorCodes.ApplicationExists;
pub const COMAdminErrRoleExists = COMAdminErrorCodes.RoleExists;
pub const COMAdminErrCantCopyFile = COMAdminErrorCodes.CantCopyFile;
pub const COMAdminErrNoUser = COMAdminErrorCodes.NoUser;
pub const COMAdminErrInvalidUserids = COMAdminErrorCodes.InvalidUserids;
pub const COMAdminErrNoRegistryCLSID = COMAdminErrorCodes.NoRegistryCLSID;
pub const COMAdminErrBadRegistryProgID = COMAdminErrorCodes.BadRegistryProgID;
pub const COMAdminErrAuthenticationLevel = COMAdminErrorCodes.AuthenticationLevel;
pub const COMAdminErrUserPasswdNotValid = COMAdminErrorCodes.UserPasswdNotValid;
pub const COMAdminErrCLSIDOrIIDMismatch = COMAdminErrorCodes.CLSIDOrIIDMismatch;
pub const COMAdminErrRemoteInterface = COMAdminErrorCodes.RemoteInterface;
pub const COMAdminErrDllRegisterServer = COMAdminErrorCodes.DllRegisterServer;
pub const COMAdminErrNoServerShare = COMAdminErrorCodes.NoServerShare;
pub const COMAdminErrDllLoadFailed = COMAdminErrorCodes.DllLoadFailed;
pub const COMAdminErrBadRegistryLibID = COMAdminErrorCodes.BadRegistryLibID;
pub const COMAdminErrAppDirNotFound = COMAdminErrorCodes.AppDirNotFound;
pub const COMAdminErrRegistrarFailed = COMAdminErrorCodes.RegistrarFailed;
pub const COMAdminErrCompFileDoesNotExist = COMAdminErrorCodes.CompFileDoesNotExist;
pub const COMAdminErrCompFileLoadDLLFail = COMAdminErrorCodes.CompFileLoadDLLFail;
pub const COMAdminErrCompFileGetClassObj = COMAdminErrorCodes.CompFileGetClassObj;
pub const COMAdminErrCompFileClassNotAvail = COMAdminErrorCodes.CompFileClassNotAvail;
pub const COMAdminErrCompFileBadTLB = COMAdminErrorCodes.CompFileBadTLB;
pub const COMAdminErrCompFileNotInstallable = COMAdminErrorCodes.CompFileNotInstallable;
pub const COMAdminErrNotChangeable = COMAdminErrorCodes.NotChangeable;
pub const COMAdminErrNotDeletable = COMAdminErrorCodes.NotDeletable;
pub const COMAdminErrSession = COMAdminErrorCodes.Session;
pub const COMAdminErrCompMoveLocked = COMAdminErrorCodes.CompMoveLocked;
pub const COMAdminErrCompMoveBadDest = COMAdminErrorCodes.CompMoveBadDest;
pub const COMAdminErrRegisterTLB = COMAdminErrorCodes.RegisterTLB;
pub const COMAdminErrSystemApp = COMAdminErrorCodes.SystemApp;
pub const COMAdminErrCompFileNoRegistrar = COMAdminErrorCodes.CompFileNoRegistrar;
pub const COMAdminErrCoReqCompInstalled = COMAdminErrorCodes.CoReqCompInstalled;
pub const COMAdminErrServiceNotInstalled = COMAdminErrorCodes.ServiceNotInstalled;
pub const COMAdminErrPropertySaveFailed = COMAdminErrorCodes.PropertySaveFailed;
pub const COMAdminErrObjectExists = COMAdminErrorCodes.ObjectExists;
pub const COMAdminErrComponentExists = COMAdminErrorCodes.ComponentExists;
pub const COMAdminErrRegFileCorrupt = COMAdminErrorCodes.RegFileCorrupt;
pub const COMAdminErrPropertyOverflow = COMAdminErrorCodes.PropertyOverflow;
pub const COMAdminErrNotInRegistry = COMAdminErrorCodes.NotInRegistry;
pub const COMAdminErrObjectNotPoolable = COMAdminErrorCodes.ObjectNotPoolable;
pub const COMAdminErrApplidMatchesClsid = COMAdminErrorCodes.ApplidMatchesClsid;
pub const COMAdminErrRoleDoesNotExist = COMAdminErrorCodes.RoleDoesNotExist;
pub const COMAdminErrStartAppNeedsComponents = COMAdminErrorCodes.StartAppNeedsComponents;
pub const COMAdminErrRequiresDifferentPlatform = COMAdminErrorCodes.RequiresDifferentPlatform;
pub const COMAdminErrQueuingServiceNotAvailable = COMAdminErrorCodes.QueuingServiceNotAvailable;
pub const COMAdminErrObjectParentMissing = COMAdminErrorCodes.ObjectParentMissing;
pub const COMAdminErrObjectDoesNotExist = COMAdminErrorCodes.ObjectDoesNotExist;
pub const COMAdminErrCanNotExportAppProxy = COMAdminErrorCodes.CanNotExportAppProxy;
pub const COMAdminErrCanNotStartApp = COMAdminErrorCodes.CanNotStartApp;
pub const COMAdminErrCanNotExportSystemApp = COMAdminErrorCodes.CanNotExportSystemApp;
pub const COMAdminErrCanNotSubscribeToComponent = COMAdminErrorCodes.CanNotSubscribeToComponent;
pub const COMAdminErrAppNotRunning = COMAdminErrorCodes.AppNotRunning;
pub const COMAdminErrEventClassCannotBeSubscriber = COMAdminErrorCodes.EventClassCannotBeSubscriber;
pub const COMAdminErrLibAppProxyIncompatible = COMAdminErrorCodes.LibAppProxyIncompatible;
pub const COMAdminErrBasePartitionOnly = COMAdminErrorCodes.BasePartitionOnly;
pub const COMAdminErrDuplicatePartitionName = COMAdminErrorCodes.DuplicatePartitionName;
pub const COMAdminErrPartitionInUse = COMAdminErrorCodes.PartitionInUse;
pub const COMAdminErrImportedComponentsNotAllowed = COMAdminErrorCodes.ImportedComponentsNotAllowed;
pub const COMAdminErrRegdbNotInitialized = COMAdminErrorCodes.RegdbNotInitialized;
pub const COMAdminErrRegdbNotOpen = COMAdminErrorCodes.RegdbNotOpen;
pub const COMAdminErrRegdbSystemErr = COMAdminErrorCodes.RegdbSystemErr;
pub const COMAdminErrRegdbAlreadyRunning = COMAdminErrorCodes.RegdbAlreadyRunning;
pub const COMAdminErrMigVersionNotSupported = COMAdminErrorCodes.MigVersionNotSupported;
pub const COMAdminErrMigSchemaNotFound = COMAdminErrorCodes.MigSchemaNotFound;
pub const COMAdminErrCatBitnessMismatch = COMAdminErrorCodes.CatBitnessMismatch;
pub const COMAdminErrCatUnacceptableBitness = COMAdminErrorCodes.CatUnacceptableBitness;
pub const COMAdminErrCatWrongAppBitnessBitness = COMAdminErrorCodes.CatWrongAppBitnessBitness;
pub const COMAdminErrCatPauseResumeNotSupported = COMAdminErrorCodes.CatPauseResumeNotSupported;
pub const COMAdminErrCatServerFault = COMAdminErrorCodes.CatServerFault;
pub const COMAdminErrCantRecycleLibraryApps = COMAdminErrorCodes.CantRecycleLibraryApps;
pub const COMAdminErrCantRecycleServiceApps = COMAdminErrorCodes.CantRecycleServiceApps;
pub const COMAdminErrProcessAlreadyRecycled = COMAdminErrorCodes.ProcessAlreadyRecycled;
pub const COMAdminErrPausedProcessMayNotBeRecycled = COMAdminErrorCodes.PausedProcessMayNotBeRecycled;
pub const COMAdminErrInvalidPartition = COMAdminErrorCodes.InvalidPartition;
pub const COMAdminErrPartitionMsiOnly = COMAdminErrorCodes.PartitionMsiOnly;
pub const COMAdminErrStartAppDisabled = COMAdminErrorCodes.StartAppDisabled;
pub const COMAdminErrCompMoveSource = COMAdminErrorCodes.CompMoveSource;
pub const COMAdminErrCompMoveDest = COMAdminErrorCodes.CompMoveDest;
pub const COMAdminErrCompMovePrivate = COMAdminErrorCodes.CompMovePrivate;
pub const COMAdminErrCannotCopyEventClass = COMAdminErrorCodes.CannotCopyEventClass;

// TODO: this type is limited to platform 'windows5.0'
const IID_ISecurityIdentityColl_Value = Guid.initString("cafc823c-b441-11d1-b82b-0000f8757e2a");
pub const IID_ISecurityIdentityColl = &IID_ISecurityIdentityColl_Value;
pub const ISecurityIdentityColl = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityIdentityColl,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityIdentityColl,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityIdentityColl,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityIdentityColl,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityIdentityColl,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityIdentityColl,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityIdentityColl_get_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityIdentityColl, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityIdentityColl_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) HRESULT {
                return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityIdentityColl, @ptrCast(self)), name, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityIdentityColl_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) HRESULT {
                return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityIdentityColl, @ptrCast(self)), ppEnum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISecurityCallersColl_Value = Guid.initString("cafc823d-b441-11d1-b82b-0000f8757e2a");
pub const IID_ISecurityCallersColl = &IID_ISecurityCallersColl_Value;
pub const ISecurityCallersColl = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallersColl,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallersColl,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallersColl,
                lIndex: i32,
                pObj: ?*?*ISecurityIdentityColl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallersColl,
                lIndex: i32,
                pObj: ?*?*ISecurityIdentityColl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallersColl,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallersColl,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallersColl_get_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityCallersColl, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallersColl_get_Item(self: *const T, lIndex: i32, pObj: ?*?*ISecurityIdentityColl) HRESULT {
                return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityCallersColl, @ptrCast(self)), lIndex, pObj);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallersColl_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) HRESULT {
                return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityCallersColl, @ptrCast(self)), ppEnum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISecurityCallContext_Value = Guid.initString("cafc823e-b441-11d1-b82b-0000f8757e2a");
pub const IID_ISecurityCallContext = &IID_ISecurityCallContext_Value;
pub const ISecurityCallContext = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallContext,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallContext,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallContext,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallContext,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISecurityCallContext,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISecurityCallContext,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsCallerInRole: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityCallContext,
                bstrRole: ?BSTR,
                pfInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityCallContext,
                bstrRole: ?BSTR,
                pfInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsSecurityEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityCallContext,
                pfIsEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityCallContext,
                pfIsEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsUserInRole: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityCallContext,
                pUser: ?*VARIANT,
                bstrRole: ?BSTR,
                pfInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityCallContext,
                pUser: ?*VARIANT,
                bstrRole: ?BSTR,
                pfInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_get_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityCallContext, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityCallContext, @ptrCast(self)), name, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityCallContext, @ptrCast(self)), ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pfInRole: ?*i16) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const ISecurityCallContext, @ptrCast(self)), bstrRole, pfInRole);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_IsSecurityEnabled(self: *const T, pfIsEnabled: ?*i16) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const ISecurityCallContext, @ptrCast(self)), pfIsEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityCallContext_IsUserInRole(self: *const T, pUser: ?*VARIANT, bstrRole: ?BSTR, pfInRole: ?*i16) HRESULT {
                return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsUserInRole(@as(*const ISecurityCallContext, @ptrCast(self)), pUser, bstrRole, pfInRole);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IGetSecurityCallContext_Value = Guid.initString("cafc823f-b441-11d1-b82b-0000f8757e2a");
pub const IID_IGetSecurityCallContext = &IID_IGetSecurityCallContext_Value;
pub const IGetSecurityCallContext = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetSecurityCallContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetSecurityCallContext,
                ppObject: ?*?*ISecurityCallContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetSecurityCallContext,
                ppObject: ?*?*ISecurityCallContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetSecurityCallContext_GetSecurityCallContext(self: *const T, ppObject: ?*?*ISecurityCallContext) HRESULT {
                return @as(*const IGetSecurityCallContext.VTable, @ptrCast(self.vtable)).GetSecurityCallContext(@as(*const IGetSecurityCallContext, @ptrCast(self)), ppObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_SecurityProperty_Value = Guid.initString("e74a7215-014d-11d1-a63c-00a0c911b4e0");
pub const IID_SecurityProperty = &IID_SecurityProperty_Value;
pub const SecurityProperty = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetDirectCallerName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDirectCreatorName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOriginalCallerName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOriginalCreatorName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const SecurityProperty,
                bstrUserName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn SecurityProperty_GetDirectCallerName(self: *const T, bstrUserName: ?*?BSTR) HRESULT {
                return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCallerName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn SecurityProperty_GetDirectCreatorName(self: *const T, bstrUserName: ?*?BSTR) HRESULT {
                return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCreatorName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn SecurityProperty_GetOriginalCallerName(self: *const T, bstrUserName: ?*?BSTR) HRESULT {
                return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCallerName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn SecurityProperty_GetOriginalCreatorName(self: *const T, bstrUserName: ?*?BSTR) HRESULT {
                return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCreatorName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ContextInfo_Value = Guid.initString("19a5a02c-0ac8-11d2-b286-00c04f8ef934");
pub const IID_ContextInfo = &IID_ContextInfo_Value;
pub const ContextInfo = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        IsInTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo,
                pbIsInTx: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo,
                pbIsInTx: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo,
                ppTx: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo,
                ppTx: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo,
                pbstrTxId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo,
                pbstrTxId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetActivityId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo,
                pbstrActivityId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo,
                pbstrActivityId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetContextId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo,
                pbstrCtxId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo,
                pbstrCtxId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo_IsInTransaction(self: *const T, pbIsInTx: ?*i16) HRESULT {
                return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const ContextInfo, @ptrCast(self)), pbIsInTx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo_GetTransaction(self: *const T, ppTx: ?*?*IUnknown) HRESULT {
                return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const ContextInfo, @ptrCast(self)), ppTx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo_GetTransactionId(self: *const T, pbstrTxId: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetTransactionId(@as(*const ContextInfo, @ptrCast(self)), pbstrTxId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo_GetActivityId(self: *const T, pbstrActivityId: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const ContextInfo, @ptrCast(self)), pbstrActivityId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo_GetContextId(self: *const T, pbstrCtxId: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetContextId(@as(*const ContextInfo, @ptrCast(self)), pbstrCtxId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ContextInfo2_Value = Guid.initString("c99d6e75-2375-11d4-8331-00c04f605588");
pub const IID_ContextInfo2 = &IID_ContextInfo2_Value;
pub const ContextInfo2 = extern struct {
    pub const VTable = extern struct {
        base: ContextInfo.VTable,
        GetPartitionId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20000: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20000: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20001: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20001: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationInstanceId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20002: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ContextInfo2,
                __MIDL__ContextInfo20002: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace ContextInfo.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo2_GetPartitionId(self: *const T, __MIDL__ContextInfo20000: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetPartitionId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20000);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo2_GetApplicationId(self: *const T, __MIDL__ContextInfo20001: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20001);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ContextInfo2_GetApplicationInstanceId(self: *const T, __MIDL__ContextInfo20002: ?*?BSTR) HRESULT {
                return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20002);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ObjectContext_Value = Guid.initString("74c08646-cedb-11cf-8b49-00aa00b8a790");
pub const IID_ObjectContext = &IID_ObjectContext_Value;
pub const ObjectContext = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
                bstrProgID: ?BSTR,
                pObject: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
                bstrProgID: ?BSTR,
                pObject: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DisableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsInTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
                pbIsInTx: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
                pbIsInTx: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsSecurityEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
                pbIsEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
                pbIsEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsCallerInRole: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectContext,
                bstrRole: ?BSTR,
                pbInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectContext,
                bstrRole: ?BSTR,
                pbInRole: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ObjectContext,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ObjectContext,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ObjectContext,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ObjectContext,
                name: ?BSTR,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ObjectContext,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ObjectContext,
                ppEnum: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Security: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ObjectContext,
                ppSecurityProperty: ?*?*SecurityProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ObjectContext,
                ppSecurityProperty: ?*?*SecurityProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ContextInfo: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ObjectContext,
                ppContextInfo: ?*?*ContextInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ObjectContext,
                ppContextInfo: ?*?*ContextInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_CreateInstance(self: *const T, bstrProgID: ?BSTR, pObject: ?*VARIANT) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ObjectContext, @ptrCast(self)), bstrProgID, pObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_SetComplete(self: *const T) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).SetComplete(@as(*const ObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_SetAbort(self: *const T) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).SetAbort(@as(*const ObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_EnableCommit(self: *const T) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).EnableCommit(@as(*const ObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_DisableCommit(self: *const T) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).DisableCommit(@as(*const ObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_IsInTransaction(self: *const T, pbIsInTx: ?*i16) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const ObjectContext, @ptrCast(self)), pbIsInTx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_IsSecurityEnabled(self: *const T, pbIsEnabled: ?*i16) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const ObjectContext, @ptrCast(self)), pbIsEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pbInRole: ?*i16) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const ObjectContext, @ptrCast(self)), bstrRole, pbInRole);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_get_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ObjectContext, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ObjectContext, @ptrCast(self)), name, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ObjectContext, @ptrCast(self)), ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_get_Security(self: *const T, ppSecurityProperty: ?*?*SecurityProperty) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Security(@as(*const ObjectContext, @ptrCast(self)), ppSecurityProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectContext_get_ContextInfo(self: *const T, ppContextInfo: ?*?*ContextInfo) HRESULT {
                return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_ContextInfo(@as(*const ObjectContext, @ptrCast(self)), ppContextInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ITransactionContextEx_Value = Guid.initString("7999fc22-d3c6-11cf-acab-00a024a55aef");
pub const IID_ITransactionContextEx = &IID_ITransactionContextEx_Value;
pub const ITransactionContextEx = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContextEx,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContextEx,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Commit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContextEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContextEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Abort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContextEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContextEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContextEx_CreateInstance(self: *const T, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) HRESULT {
                return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ITransactionContextEx, @ptrCast(self)), rclsid, riid, pObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContextEx_Commit(self: *const T) HRESULT {
                return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionContextEx, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContextEx_Abort(self: *const T) HRESULT {
                return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionContextEx, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ITransactionContext_Value = Guid.initString("7999fc21-d3c6-11cf-acab-00a024a55aef");
pub const IID_ITransactionContext = &IID_ITransactionContext_Value;
pub const ITransactionContext = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContext,
                pszProgId: ?BSTR,
                pObject: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContext,
                pszProgId: ?BSTR,
                pObject: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Commit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Abort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContext_CreateInstance(self: *const T, pszProgId: ?BSTR, pObject: ?*VARIANT) HRESULT {
                return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ITransactionContext, @ptrCast(self)), pszProgId, pObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContext_Commit(self: *const T) HRESULT {
                return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionContext_Abort(self: *const T) HRESULT {
                return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionContext, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICreateWithTransactionEx_Value = Guid.initString("455acf57-5345-11d2-99cf-00c04f797bc9");
pub const IID_ICreateWithTransactionEx = &IID_ICreateWithTransactionEx_Value;
pub const ICreateWithTransactionEx = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICreateWithTransactionEx,
                pTransaction: ?*ITransaction,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICreateWithTransactionEx,
                pTransaction: ?*ITransaction,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICreateWithTransactionEx_CreateInstance(self: *const T, pTransaction: ?*ITransaction, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) HRESULT {
                return @as(*const ICreateWithTransactionEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ICreateWithTransactionEx, @ptrCast(self)), pTransaction, rclsid, riid, pObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ICreateWithLocalTransaction_Value = Guid.initString("227ac7a8-8423-42ce-b7cf-03061ec9aaa3");
pub const IID_ICreateWithLocalTransaction = &IID_ICreateWithLocalTransaction_Value;
pub const ICreateWithLocalTransaction = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateInstanceWithSysTx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICreateWithLocalTransaction,
                pTransaction: ?*IUnknown,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICreateWithLocalTransaction,
                pTransaction: ?*IUnknown,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICreateWithLocalTransaction_CreateInstanceWithSysTx(self: *const T, pTransaction: ?*IUnknown, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) HRESULT {
                return @as(*const ICreateWithLocalTransaction.VTable, @ptrCast(self.vtable)).CreateInstanceWithSysTx(@as(*const ICreateWithLocalTransaction, @ptrCast(self)), pTransaction, rclsid, riid, pObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICreateWithTipTransactionEx_Value = Guid.initString("455acf59-5345-11d2-99cf-00c04f797bc9");
pub const IID_ICreateWithTipTransactionEx = &IID_ICreateWithTipTransactionEx_Value;
pub const ICreateWithTipTransactionEx = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICreateWithTipTransactionEx,
                bstrTipUrl: ?BSTR,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICreateWithTipTransactionEx,
                bstrTipUrl: ?BSTR,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                pObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICreateWithTipTransactionEx_CreateInstance(self: *const T, bstrTipUrl: ?BSTR, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) HRESULT {
                return @as(*const ICreateWithTipTransactionEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ICreateWithTipTransactionEx, @ptrCast(self)), bstrTipUrl, rclsid, riid, pObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const COMSVCSEVENTINFO = extern struct {
    cbSize: u32,
    dwPid: u32,
    lTime: i64,
    lMicroTime: i32,
    perfCount: i64,
    guidApp: Guid,
    sMachineName: ?PWSTR,
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComLTxEvents_Value = Guid.initString("605cf82c-578e-4298-975d-82babcd9e053");
pub const IID_IComLTxEvents = &IID_IComLTxEvents_Value;
pub const IComLTxEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnLtxTransactionStart: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                tsid: Guid,
                fRoot: BOOL,
                nIsolationLevel: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                tsid: Guid,
                fRoot: BOOL,
                nIsolationLevel: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLtxTransactionPrepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                fVote: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                fVote: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLtxTransactionAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLtxTransactionCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLtxTransactionPromote: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                txnId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComLTxEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidLtx: Guid,
                txnId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComLTxEvents_OnLtxTransactionStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, tsid: Guid, fRoot: BOOL, nIsolationLevel: i32) HRESULT {
                return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionStart(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, tsid, fRoot, nIsolationLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComLTxEvents_OnLtxTransactionPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, fVote: BOOL) HRESULT {
                return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionPrepare(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, fVote);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComLTxEvents_OnLtxTransactionAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid) HRESULT {
                return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionAbort(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComLTxEvents_OnLtxTransactionCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid) HRESULT {
                return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionCommit(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComLTxEvents_OnLtxTransactionPromote(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, txnId: Guid) HRESULT {
                return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionPromote(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, txnId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComUserEvent_Value = Guid.initString("683130a4-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComUserEvent = &IID_IComUserEvent_Value;
pub const IComUserEvent = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnUserEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComUserEvent,
                pInfo: ?*COMSVCSEVENTINFO,
                pvarEvent: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComUserEvent,
                pInfo: ?*COMSVCSEVENTINFO,
                pvarEvent: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComUserEvent_OnUserEvent(self: *const T, pInfo: ?*COMSVCSEVENTINFO, pvarEvent: ?*VARIANT) HRESULT {
                return @as(*const IComUserEvent.VTable, @ptrCast(self.vtable)).OnUserEvent(@as(*const IComUserEvent, @ptrCast(self)), pInfo, pvarEvent);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComThreadEvents_Value = Guid.initString("683130a5-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComThreadEvents = &IID_IComThreadEvents_Value;
pub const IComThreadEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnThreadStart: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                dwThread: u32,
                dwTheadCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                dwThread: u32,
                dwTheadCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadTerminate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                dwThread: u32,
                dwTheadCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                dwThread: u32,
                dwTheadCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadBindToApartment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                AptID: u64,
                dwActCnt: u32,
                dwLowCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                AptID: u64,
                dwActCnt: u32,
                dwLowCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadUnBind: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                AptID: u64,
                dwActCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                AptID: u64,
                dwActCnt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadWorkEnque: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadWorkPrivate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadWorkPublic: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadWorkRedirect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
                ThreadNum: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
                ThreadNum: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadWorkReject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ThreadID: u64,
                MsgWorkID: u64,
                QueueLen: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadAssignApartment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                AptID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                AptID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnThreadUnassignApartment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                AptID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComThreadEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                AptID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, dwThread: u32, dwTheadCnt: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadStart(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, dwThread, dwTheadCnt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadTerminate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, dwThread: u32, dwTheadCnt: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadTerminate(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, dwThread, dwTheadCnt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadBindToApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, AptID: u64, dwActCnt: u32, dwLowCnt: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadBindToApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, AptID, dwActCnt, dwLowCnt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadUnBind(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, AptID: u64, dwActCnt: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadUnBind(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, AptID, dwActCnt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadWorkEnque(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkEnque(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadWorkPrivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkPrivate(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadWorkPublic(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkPublic(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadWorkRedirect(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32, ThreadNum: u64) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkRedirect(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen, ThreadNum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadWorkReject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkReject(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadAssignApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, AptID: u64) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadAssignApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, guidActivity, AptID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComThreadEvents_OnThreadUnassignApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, AptID: u64) HRESULT {
                return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadUnassignApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, AptID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComAppEvents_Value = Guid.initString("683130a6-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComAppEvents = &IID_IComAppEvents_Value;
pub const IComAppEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnAppActivation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppShutdown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppForceShutdown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComAppEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComAppEvents_OnAppActivation(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppActivation(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComAppEvents_OnAppShutdown(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppShutdown(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComAppEvents_OnAppForceShutdown(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppForceShutdown(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComInstanceEvents_Value = Guid.initString("683130a7-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComInstanceEvents = &IID_IComInstanceEvents_Value;
pub const IComInstanceEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjectCreate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComInstanceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                clsid: ?*const Guid,
                tsid: ?*const Guid,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComInstanceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                clsid: ?*const Guid,
                tsid: ?*const Guid,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjectDestroy: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComInstanceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComInstanceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComInstanceEvents_OnObjectCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, clsid: ?*const Guid, tsid: ?*const Guid, CtxtID: u64, ObjectID: u64) HRESULT {
                return @as(*const IComInstanceEvents.VTable, @ptrCast(self.vtable)).OnObjectCreate(@as(*const IComInstanceEvents, @ptrCast(self)), pInfo, guidActivity, clsid, tsid, CtxtID, ObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComInstanceEvents_OnObjectDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComInstanceEvents.VTable, @ptrCast(self.vtable)).OnObjectDestroy(@as(*const IComInstanceEvents, @ptrCast(self)), pInfo, CtxtID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComTransactionEvents_Value = Guid.initString("683130a8-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComTransactionEvents = &IID_IComTransactionEvents_Value;
pub const IComTransactionEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnTransactionStart: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                tsid: ?*const Guid,
                fRoot: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                tsid: ?*const Guid,
                fRoot: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionPrepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                fVoteYes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                fVoteYes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransactionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransactionEvents_OnTransactionStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, tsid: ?*const Guid, fRoot: BOOL) HRESULT {
                return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionStart(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx, tsid, fRoot);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransactionEvents_OnTransactionPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, fVoteYes: BOOL) HRESULT {
                return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionPrepare(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx, fVoteYes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransactionEvents_OnTransactionAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) HRESULT {
                return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionAbort(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransactionEvents_OnTransactionCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) HRESULT {
                return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionCommit(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComMethodEvents_Value = Guid.initString("683130a9-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComMethodEvents = &IID_IComMethodEvents_Value;
pub const IComMethodEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnMethodCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnMethodReturn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
                hresult: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
                hresult: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnMethodException: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethodEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethodEvents_OnMethodCall(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32) HRESULT {
                return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodCall(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethodEvents_OnMethodReturn(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32, hresult: HRESULT) HRESULT {
                return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodReturn(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth, hresult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethodEvents_OnMethodException(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32) HRESULT {
                return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodException(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectEvents_Value = Guid.initString("683130aa-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComObjectEvents = &IID_IComObjectEvents_Value;
pub const IComObjectEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjectActivate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjectDeactivate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
                ObjectID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnDisableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnEnableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnSetComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnSetAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnObjectActivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64, ObjectID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnObjectActivate(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID, ObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnObjectDeactivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64, ObjectID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnObjectDeactivate(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID, ObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnDisableCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnDisableCommit(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnEnableCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnEnableCommit(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnSetComplete(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnSetComplete(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectEvents_OnSetAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnSetAbort(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComResourceEvents_Value = Guid.initString("683130ab-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComResourceEvents = &IID_IComResourceEvents_Value;
pub const IComResourceEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnResourceCreate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnResourceAllocate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
                NumRated: u32,
                Rating: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
                NumRated: u32,
                Rating: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnResourceRecycle: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnResourceDestroy: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                hr: HRESULT,
                pszType: ?[*:0]const u16,
                resId: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                hr: HRESULT,
                pszType: ?[*:0]const u16,
                resId: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnResourceTrack: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComResourceEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjectID: u64,
                pszType: ?[*:0]const u16,
                resId: u64,
                enlisted: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComResourceEvents_OnResourceCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL) HRESULT {
                return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceCreate(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComResourceEvents_OnResourceAllocate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL, NumRated: u32, Rating: u32) HRESULT {
                return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceAllocate(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted, NumRated, Rating);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComResourceEvents_OnResourceRecycle(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64) HRESULT {
                return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceRecycle(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComResourceEvents_OnResourceDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, hr: HRESULT, pszType: ?[*:0]const u16, resId: u64) HRESULT {
                return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceDestroy(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, hr, pszType, resId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComResourceEvents_OnResourceTrack(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL) HRESULT {
                return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceTrack(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComSecurityEvents_Value = Guid.initString("683130ac-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComSecurityEvents = &IID_IComSecurityEvents_Value;
pub const IComSecurityEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnAuthenticate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComSecurityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                ObjectID: u64,
                guidIID: ?*const Guid,
                iMeth: u32,
                cbByteOrig: u32,
                pSidOriginalUser: [*:0]u8,
                cbByteCur: u32,
                pSidCurrentUser: [*:0]u8,
                bCurrentUserInpersonatingInProc: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComSecurityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                ObjectID: u64,
                guidIID: ?*const Guid,
                iMeth: u32,
                cbByteOrig: u32,
                pSidOriginalUser: [*:0]u8,
                cbByteCur: u32,
                pSidCurrentUser: [*:0]u8,
                bCurrentUserInpersonatingInProc: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAuthenticateFail: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComSecurityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                ObjectID: u64,
                guidIID: ?*const Guid,
                iMeth: u32,
                cbByteOrig: u32,
                pSidOriginalUser: [*:0]u8,
                cbByteCur: u32,
                pSidCurrentUser: [*:0]u8,
                bCurrentUserInpersonatingInProc: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComSecurityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                ObjectID: u64,
                guidIID: ?*const Guid,
                iMeth: u32,
                cbByteOrig: u32,
                pSidOriginalUser: [*:0]u8,
                cbByteCur: u32,
                pSidCurrentUser: [*:0]u8,
                bCurrentUserInpersonatingInProc: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComSecurityEvents_OnAuthenticate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, ObjectID: u64, guidIID: ?*const Guid, iMeth: u32, cbByteOrig: u32, pSidOriginalUser: [*:0]u8, cbByteCur: u32, pSidCurrentUser: [*:0]u8, bCurrentUserInpersonatingInProc: BOOL) HRESULT {
                return @as(*const IComSecurityEvents.VTable, @ptrCast(self.vtable)).OnAuthenticate(@as(*const IComSecurityEvents, @ptrCast(self)), pInfo, guidActivity, ObjectID, guidIID, iMeth, cbByteOrig, pSidOriginalUser, cbByteCur, pSidCurrentUser, bCurrentUserInpersonatingInProc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComSecurityEvents_OnAuthenticateFail(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, ObjectID: u64, guidIID: ?*const Guid, iMeth: u32, cbByteOrig: u32, pSidOriginalUser: [*:0]u8, cbByteCur: u32, pSidCurrentUser: [*:0]u8, bCurrentUserInpersonatingInProc: BOOL) HRESULT {
                return @as(*const IComSecurityEvents.VTable, @ptrCast(self.vtable)).OnAuthenticateFail(@as(*const IComSecurityEvents, @ptrCast(self)), pInfo, guidActivity, ObjectID, guidIID, iMeth, cbByteOrig, pSidOriginalUser, cbByteCur, pSidCurrentUser, bCurrentUserInpersonatingInProc);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectPoolEvents_Value = Guid.initString("683130ad-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComObjectPoolEvents = &IID_IComObjectPoolEvents_Value;
pub const IComObjectPoolEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjPoolPutObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                nReason: i32,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                nReason: i32,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolGetObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolRecycleToTx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolGetFromTx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents_OnObjPoolPutObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, nReason: i32, dwAvailable: u32, oid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolPutObject(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidObject, nReason, dwAvailable, oid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents_OnObjPoolGetObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, dwAvailable: u32, oid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolGetObject(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, dwAvailable, oid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents_OnObjPoolRecycleToTx(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolRecycleToTx(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents_OnObjPoolGetFromTx(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolGetFromTx(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectPoolEvents2_Value = Guid.initString("683130ae-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComObjectPoolEvents2 = &IID_IComObjectPoolEvents2_Value;
pub const IComObjectPoolEvents2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjPoolCreateObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwObjsCreated: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwObjsCreated: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolDestroyObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwObjsCreated: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwObjsCreated: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolCreateDecision: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                dwThreadsWaiting: u32,
                dwAvail: u32,
                dwCreated: u32,
                dwMin: u32,
                dwMax: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                dwThreadsWaiting: u32,
                dwAvail: u32,
                dwCreated: u32,
                dwMin: u32,
                dwMax: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolTimeout: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                guidActivity: ?*const Guid,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                guidActivity: ?*const Guid,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolCreatePool: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwMin: u32,
                dwMax: u32,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPoolEvents2,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                dwMin: u32,
                dwMax: u32,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents2_OnObjPoolCreateObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwObjsCreated: u32, oid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreateObject(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwObjsCreated, oid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents2_OnObjPoolDestroyObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwObjsCreated: u32, oid: u64) HRESULT {
                return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolDestroyObject(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwObjsCreated, oid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents2_OnObjPoolCreateDecision(self: *const T, pInfo: ?*COMSVCSEVENTINFO, dwThreadsWaiting: u32, dwAvail: u32, dwCreated: u32, dwMin: u32, dwMax: u32) HRESULT {
                return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreateDecision(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, dwThreadsWaiting, dwAvail, dwCreated, dwMin, dwMax);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents2_OnObjPoolTimeout(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, guidActivity: ?*const Guid, dwTimeout: u32) HRESULT {
                return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolTimeout(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, guidActivity, dwTimeout);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPoolEvents2_OnObjPoolCreatePool(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwMin: u32, dwMax: u32, dwTimeout: u32) HRESULT {
                return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreatePool(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwMin, dwMax, dwTimeout);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectConstructionEvents_Value = Guid.initString("683130af-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComObjectConstructionEvents = &IID_IComObjectConstructionEvents_Value;
pub const IComObjectConstructionEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjectConstruct: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectConstructionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                sConstructString: ?[*:0]const u16,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectConstructionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                sConstructString: ?[*:0]const u16,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectConstructionEvents_OnObjectConstruct(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, sConstructString: ?[*:0]const u16, oid: u64) HRESULT {
                return @as(*const IComObjectConstructionEvents.VTable, @ptrCast(self.vtable)).OnObjectConstruct(@as(*const IComObjectConstructionEvents, @ptrCast(self)), pInfo, guidObject, sConstructString, oid);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComActivityEvents_Value = Guid.initString("683130b0-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComActivityEvents = &IID_IComActivityEvents_Value;
pub const IComActivityEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnActivityCreate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityDestroy: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityEnter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidEntered: ?*const Guid,
                dwThread: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidEntered: ?*const Guid,
                dwThread: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityTimeout: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidEntered: ?*const Guid,
                dwThread: u32,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidEntered: ?*const Guid,
                dwThread: u32,
                dwTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityReenter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                dwThread: u32,
                dwCallDepth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                dwThread: u32,
                dwCallDepth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityLeave: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidLeft: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                guidLeft: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnActivityLeaveSame: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                dwCallDepth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComActivityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidCurrent: ?*const Guid,
                dwCallDepth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityCreate(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidActivity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityDestroy(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidActivity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityEnter(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidEntered: ?*const Guid, dwThread: u32) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityEnter(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidEntered, dwThread);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityTimeout(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidEntered: ?*const Guid, dwThread: u32, dwTimeout: u32) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityTimeout(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidEntered, dwThread, dwTimeout);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityReenter(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, dwThread: u32, dwCallDepth: u32) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityReenter(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, dwThread, dwCallDepth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityLeave(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidLeft: ?*const Guid) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityLeave(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidLeft);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComActivityEvents_OnActivityLeaveSame(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, dwCallDepth: u32) HRESULT {
                return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityLeaveSame(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, dwCallDepth);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComIdentityEvents_Value = Guid.initString("683130b1-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComIdentityEvents = &IID_IComIdentityEvents_Value;
pub const IComIdentityEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnIISRequestInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComIdentityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjId: u64,
                pszClientIP: ?[*:0]const u16,
                pszServerIP: ?[*:0]const u16,
                pszURL: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComIdentityEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                ObjId: u64,
                pszClientIP: ?[*:0]const u16,
                pszServerIP: ?[*:0]const u16,
                pszURL: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComIdentityEvents_OnIISRequestInfo(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjId: u64, pszClientIP: ?[*:0]const u16, pszServerIP: ?[*:0]const u16, pszURL: ?[*:0]const u16) HRESULT {
                return @as(*const IComIdentityEvents.VTable, @ptrCast(self.vtable)).OnIISRequestInfo(@as(*const IComIdentityEvents, @ptrCast(self)), pInfo, ObjId, pszClientIP, pszServerIP, pszURL);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComQCEvents_Value = Guid.initString("683130b2-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComQCEvents = &IID_IComQCEvents_Value;
pub const IComQCEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnQCRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                objid: u64,
                szQueue: *[60]u16,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                msmqhr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                objid: u64,
                szQueue: *[60]u16,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                msmqhr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCQueueOpen: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                szQueue: *[60]u16,
                QueueID: u64,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                szQueue: *[60]u16,
                QueueID: u64,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCReceive: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                QueueID: u64,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                QueueID: u64,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCReceiveFail: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                QueueID: u64,
                msmqhr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                QueueID: u64,
                msmqhr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCMoveToReTryQueue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                RetryIndex: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                RetryIndex: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCMoveToDeadQueue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnQCPlayback: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                objid: u64,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComQCEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                objid: u64,
                guidMsgId: ?*const Guid,
                guidWorkFlowId: ?*const Guid,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCRecord(self: *const T, pInfo: ?*COMSVCSEVENTINFO, objid: u64, szQueue: *[60]u16, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, msmqhr: HRESULT) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCRecord(@as(*const IComQCEvents, @ptrCast(self)), pInfo, objid, szQueue, guidMsgId, guidWorkFlowId, msmqhr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCQueueOpen(self: *const T, pInfo: ?*COMSVCSEVENTINFO, szQueue: *[60]u16, QueueID: u64, hr: HRESULT) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCQueueOpen(@as(*const IComQCEvents, @ptrCast(self)), pInfo, szQueue, QueueID, hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCReceive(self: *const T, pInfo: ?*COMSVCSEVENTINFO, QueueID: u64, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, hr: HRESULT) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCReceive(@as(*const IComQCEvents, @ptrCast(self)), pInfo, QueueID, guidMsgId, guidWorkFlowId, hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCReceiveFail(self: *const T, pInfo: ?*COMSVCSEVENTINFO, QueueID: u64, msmqhr: HRESULT) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCReceiveFail(@as(*const IComQCEvents, @ptrCast(self)), pInfo, QueueID, msmqhr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCMoveToReTryQueue(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, RetryIndex: u32) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCMoveToReTryQueue(@as(*const IComQCEvents, @ptrCast(self)), pInfo, guidMsgId, guidWorkFlowId, RetryIndex);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCMoveToDeadQueue(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCMoveToDeadQueue(@as(*const IComQCEvents, @ptrCast(self)), pInfo, guidMsgId, guidWorkFlowId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComQCEvents_OnQCPlayback(self: *const T, pInfo: ?*COMSVCSEVENTINFO, objid: u64, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, hr: HRESULT) HRESULT {
                return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCPlayback(@as(*const IComQCEvents, @ptrCast(self)), pInfo, objid, guidMsgId, guidWorkFlowId, hr);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComExceptionEvents_Value = Guid.initString("683130b3-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComExceptionEvents = &IID_IComExceptionEvents_Value;
pub const IComExceptionEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnExceptionUser: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComExceptionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                code: u32,
                address: u64,
                pszStackTrace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComExceptionEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                code: u32,
                address: u64,
                pszStackTrace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComExceptionEvents_OnExceptionUser(self: *const T, pInfo: ?*COMSVCSEVENTINFO, code: u32, address: u64, pszStackTrace: ?[*:0]const u16) HRESULT {
                return @as(*const IComExceptionEvents.VTable, @ptrCast(self.vtable)).OnExceptionUser(@as(*const IComExceptionEvents, @ptrCast(self)), pInfo, code, address, pszStackTrace);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ILBEvents_Value = Guid.initString("683130b4-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_ILBEvents = &IID_ILBEvents_Value;
pub const ILBEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        TargetUp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILBEvents,
                bstrServerName: ?BSTR,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILBEvents,
                bstrServerName: ?BSTR,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TargetDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILBEvents,
                bstrServerName: ?BSTR,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILBEvents,
                bstrServerName: ?BSTR,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EngineDefined: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILBEvents,
                bstrPropName: ?BSTR,
                varPropValue: ?*VARIANT,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILBEvents,
                bstrPropName: ?BSTR,
                varPropValue: ?*VARIANT,
                bstrClsidEng: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILBEvents_TargetUp(self: *const T, bstrServerName: ?BSTR, bstrClsidEng: ?BSTR) HRESULT {
                return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).TargetUp(@as(*const ILBEvents, @ptrCast(self)), bstrServerName, bstrClsidEng);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILBEvents_TargetDown(self: *const T, bstrServerName: ?BSTR, bstrClsidEng: ?BSTR) HRESULT {
                return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).TargetDown(@as(*const ILBEvents, @ptrCast(self)), bstrServerName, bstrClsidEng);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILBEvents_EngineDefined(self: *const T, bstrPropName: ?BSTR, varPropValue: ?*VARIANT, bstrClsidEng: ?BSTR) HRESULT {
                return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).EngineDefined(@as(*const ILBEvents, @ptrCast(self)), bstrPropName, varPropValue, bstrClsidEng);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComCRMEvents_Value = Guid.initString("683130b5-2e50-11d2-98a5-00c04f8ee1c4");
pub const IID_IComCRMEvents = &IID_IComCRMEvents_Value;
pub const IComCRMEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnCRMRecoveryStart: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMRecoveryDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMCheckpoint: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMBegin: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                guidActivity: Guid,
                guidTx: Guid,
                szProgIdCompensator: *[64]u16,
                szDescription: *[64]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                guidActivity: Guid,
                guidTx: Guid,
                szProgIdCompensator: *[64]u16,
                szDescription: *[64]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMPrepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMIndoubt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMRelease: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMAnalyze: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                dwCrmRecordType: u32,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                dwCrmRecordType: u32,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMWrite: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                fVariants: BOOL,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                fVariants: BOOL,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMForget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMForce: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnCRMDeliver: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                fVariants: BOOL,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComCRMEvents,
                pInfo: ?*COMSVCSEVENTINFO,
                guidClerkCLSID: Guid,
                fVariants: BOOL,
                dwRecordSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMRecoveryStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRecoveryStart(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMRecoveryDone(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRecoveryDone(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMCheckpoint(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMCheckpoint(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMBegin(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, guidActivity: Guid, guidTx: Guid, szProgIdCompensator: *[64]u16, szDescription: *[64]u16) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMBegin(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, guidActivity, guidTx, szProgIdCompensator, szDescription);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMPrepare(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMCommit(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMAbort(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMIndoubt(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMIndoubt(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMDone(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMDone(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMRelease(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRelease(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMAnalyze(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, dwCrmRecordType: u32, dwRecordSize: u32) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMAnalyze(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, dwCrmRecordType, dwRecordSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMWrite(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, fVariants: BOOL, dwRecordSize: u32) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMWrite(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, fVariants, dwRecordSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMForget(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMForget(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMForce(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMForce(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComCRMEvents_OnCRMDeliver(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, fVariants: BOOL, dwRecordSize: u32) HRESULT {
                return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMDeliver(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, fVariants, dwRecordSize);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComMethod2Events_Value = Guid.initString("fb388aaa-567d-4024-af8e-6e93ee748573");
pub const IID_IComMethod2Events = &IID_IComMethod2Events_Value;
pub const IComMethod2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnMethodCall2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnMethodReturn2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
                hresult: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
                hresult: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnMethodException2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMethod2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                oid: u64,
                guidCid: ?*const Guid,
                guidRid: ?*const Guid,
                dwThread: u32,
                iMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethod2Events_OnMethodCall2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32) HRESULT {
                return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodCall2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethod2Events_OnMethodReturn2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32, hresult: HRESULT) HRESULT {
                return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodReturn2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth, hresult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMethod2Events_OnMethodException2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32) HRESULT {
                return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodException2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComTrackingInfoEvents_Value = Guid.initString("4e6cdcc9-fb25-4fd5-9cc5-c9f4b6559cec");
pub const IID_IComTrackingInfoEvents = &IID_IComTrackingInfoEvents_Value;
pub const IComTrackingInfoEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnNewTrackingInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoEvents,
                pToplevelCollection: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoEvents,
                pToplevelCollection: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoEvents_OnNewTrackingInfo(self: *const T, pToplevelCollection: ?*IUnknown) HRESULT {
                return @as(*const IComTrackingInfoEvents.VTable, @ptrCast(self.vtable)).OnNewTrackingInfo(@as(*const IComTrackingInfoEvents, @ptrCast(self)), pToplevelCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const TRACKING_COLL_TYPE = enum(i32) {
    PROCESSES = 0,
    APPLICATIONS = 1,
    COMPONENTS = 2,
};
pub const TRKCOLL_PROCESSES = TRACKING_COLL_TYPE.PROCESSES;
pub const TRKCOLL_APPLICATIONS = TRACKING_COLL_TYPE.APPLICATIONS;
pub const TRKCOLL_COMPONENTS = TRACKING_COLL_TYPE.COMPONENTS;

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComTrackingInfoCollection_Value = Guid.initString("c266c677-c9ad-49ab-9fd9-d9661078588a");
pub const IID_IComTrackingInfoCollection = &IID_IComTrackingInfoCollection_Value;
pub const IComTrackingInfoCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Type: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoCollection,
                pType: ?*TRACKING_COLL_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoCollection,
                pType: ?*TRACKING_COLL_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Count: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Item: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoCollection,
                ulIndex: u32,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoCollection,
                ulIndex: u32,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoCollection_Type(self: *const T, pType: ?*TRACKING_COLL_TYPE) HRESULT {
                return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Type(@as(*const IComTrackingInfoCollection, @ptrCast(self)), pType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoCollection_Count(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Count(@as(*const IComTrackingInfoCollection, @ptrCast(self)), pCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoCollection_Item(self: *const T, ulIndex: u32, riid: ?*const Guid, ppv: ?*?*anyopaque) HRESULT {
                return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Item(@as(*const IComTrackingInfoCollection, @ptrCast(self)), ulIndex, riid, ppv);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComTrackingInfoObject_Value = Guid.initString("116e42c5-d8b1-47bf-ab1e-c895ed3e2372");
pub const IID_IComTrackingInfoObject = &IID_IComTrackingInfoObject_Value;
pub const IComTrackingInfoObject = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoObject,
                szPropertyName: ?PWSTR,
                pvarOut: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoObject,
                szPropertyName: ?PWSTR,
                pvarOut: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoObject_GetValue(self: *const T, szPropertyName: ?PWSTR, pvarOut: ?*VARIANT) HRESULT {
                return @as(*const IComTrackingInfoObject.VTable, @ptrCast(self.vtable)).GetValue(@as(*const IComTrackingInfoObject, @ptrCast(self)), szPropertyName, pvarOut);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComTrackingInfoProperties_Value = Guid.initString("789b42be-6f6b-443a-898e-67abf390aa14");
pub const IID_IComTrackingInfoProperties = &IID_IComTrackingInfoProperties_Value;
pub const IComTrackingInfoProperties = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PropCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoProperties,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoProperties,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTrackingInfoProperties,
                ulIndex: u32,
                ppszPropName: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTrackingInfoProperties,
                ulIndex: u32,
                ppszPropName: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoProperties_PropCount(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const IComTrackingInfoProperties.VTable, @ptrCast(self.vtable)).PropCount(@as(*const IComTrackingInfoProperties, @ptrCast(self)), pCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTrackingInfoProperties_GetPropName(self: *const T, ulIndex: u32, ppszPropName: ?*?PWSTR) HRESULT {
                return @as(*const IComTrackingInfoProperties.VTable, @ptrCast(self.vtable)).GetPropName(@as(*const IComTrackingInfoProperties, @ptrCast(self)), ulIndex, ppszPropName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IComApp2Events_Value = Guid.initString("1290bc1a-b219-418d-b078-5934ded08242");
pub const IID_IComApp2Events = &IID_IComApp2Events_Value;
pub const IComApp2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnAppActivation2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                guidProcess: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                guidProcess: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppShutdown2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppForceShutdown2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppPaused2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                bPaused: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                bPaused: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnAppRecycle2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                guidProcess: Guid,
                lReason: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComApp2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidApp: Guid,
                guidProcess: Guid,
                lReason: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComApp2Events_OnAppActivation2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, guidProcess: Guid) HRESULT {
                return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppActivation2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, guidProcess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComApp2Events_OnAppShutdown2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppShutdown2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComApp2Events_OnAppForceShutdown2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) HRESULT {
                return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppForceShutdown2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComApp2Events_OnAppPaused2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, bPaused: BOOL) HRESULT {
                return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppPaused2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, bPaused);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComApp2Events_OnAppRecycle2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, guidProcess: Guid, lReason: i32) HRESULT {
                return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppRecycle2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, guidProcess, lReason);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComTransaction2Events_Value = Guid.initString("a136f62a-2f94-4288-86e0-d8a1fa4c0299");
pub const IID_IComTransaction2Events = &IID_IComTransaction2Events_Value;
pub const IComTransaction2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnTransactionStart2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                tsid: ?*const Guid,
                fRoot: BOOL,
                nIsolationLevel: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                tsid: ?*const Guid,
                fRoot: BOOL,
                nIsolationLevel: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionPrepare2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                fVoteYes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
                fVoteYes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionAbort2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnTransactionCommit2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComTransaction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidTx: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransaction2Events_OnTransactionStart2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, tsid: ?*const Guid, fRoot: BOOL, nIsolationLevel: i32) HRESULT {
                return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionStart2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx, tsid, fRoot, nIsolationLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransaction2Events_OnTransactionPrepare2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, fVoteYes: BOOL) HRESULT {
                return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionPrepare2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx, fVoteYes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransaction2Events_OnTransactionAbort2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) HRESULT {
                return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionAbort2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComTransaction2Events_OnTransactionCommit2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) HRESULT {
                return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionCommit2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComInstance2Events_Value = Guid.initString("20e3bf07-b506-4ad5-a50c-d2ca5b9c158e");
pub const IID_IComInstance2Events = &IID_IComInstance2Events_Value;
pub const IComInstance2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjectCreate2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComInstance2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                clsid: ?*const Guid,
                tsid: ?*const Guid,
                CtxtID: u64,
                ObjectID: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComInstance2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                clsid: ?*const Guid,
                tsid: ?*const Guid,
                CtxtID: u64,
                ObjectID: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjectDestroy2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComInstance2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComInstance2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                CtxtID: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComInstance2Events_OnObjectCreate2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, clsid: ?*const Guid, tsid: ?*const Guid, CtxtID: u64, ObjectID: u64, guidPartition: ?*const Guid) HRESULT {
                return @as(*const IComInstance2Events.VTable, @ptrCast(self.vtable)).OnObjectCreate2(@as(*const IComInstance2Events, @ptrCast(self)), pInfo, guidActivity, clsid, tsid, CtxtID, ObjectID, guidPartition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComInstance2Events_OnObjectDestroy2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) HRESULT {
                return @as(*const IComInstance2Events.VTable, @ptrCast(self.vtable)).OnObjectDestroy2(@as(*const IComInstance2Events, @ptrCast(self)), pInfo, CtxtID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectPool2Events_Value = Guid.initString("65bf6534-85ea-4f64-8cf4-3d974b2ab1cf");
pub const IID_IComObjectPool2Events = &IID_IComObjectPool2Events_Value;
pub const IComObjectPool2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjPoolPutObject2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                nReason: i32,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                nReason: i32,
                dwAvailable: u32,
                oid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolGetObject2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                dwAvailable: u32,
                oid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                dwAvailable: u32,
                oid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolRecycleToTx2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnObjPoolGetFromTx2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectPool2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidActivity: ?*const Guid,
                guidObject: ?*const Guid,
                guidTx: ?*const Guid,
                objid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPool2Events_OnObjPoolPutObject2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, nReason: i32, dwAvailable: u32, oid: u64) HRESULT {
                return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolPutObject2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidObject, nReason, dwAvailable, oid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPool2Events_OnObjPoolGetObject2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, dwAvailable: u32, oid: u64, guidPartition: ?*const Guid) HRESULT {
                return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolGetObject2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, dwAvailable, oid, guidPartition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPool2Events_OnObjPoolRecycleToTx2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) HRESULT {
                return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolRecycleToTx2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectPool2Events_OnObjPoolGetFromTx2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64, guidPartition: ?*const Guid) HRESULT {
                return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolGetFromTx2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid, guidPartition);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IComObjectConstruction2Events_Value = Guid.initString("4b5a7827-8df2-45c0-8f6f-57ea1f856a9f");
pub const IID_IComObjectConstruction2Events = &IID_IComObjectConstruction2Events_Value;
pub const IComObjectConstruction2Events = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnObjectConstruct2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComObjectConstruction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                sConstructString: ?[*:0]const u16,
                oid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComObjectConstruction2Events,
                pInfo: ?*COMSVCSEVENTINFO,
                guidObject: ?*const Guid,
                sConstructString: ?[*:0]const u16,
                oid: u64,
                guidPartition: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComObjectConstruction2Events_OnObjectConstruct2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, sConstructString: ?[*:0]const u16, oid: u64, guidPartition: ?*const Guid) HRESULT {
                return @as(*const IComObjectConstruction2Events.VTable, @ptrCast(self.vtable)).OnObjectConstruct2(@as(*const IComObjectConstruction2Events, @ptrCast(self)), pInfo, guidObject, sConstructString, oid, guidPartition);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISystemAppEventData_Value = Guid.initString("d6d48a3c-d5c5-49e7-8c74-99e4889ed52f");
pub const IID_ISystemAppEventData = &IID_ISystemAppEventData_Value;
pub const ISystemAppEventData = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Startup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISystemAppEventData,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISystemAppEventData,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnDataChanged: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISystemAppEventData,
                dwPID: u32,
                dwMask: u32,
                dwNumberSinks: u32,
                bstrDwMethodMask: ?BSTR,
                dwReason: u32,
                u64TraceHandle: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISystemAppEventData,
                dwPID: u32,
                dwMask: u32,
                dwNumberSinks: u32,
                bstrDwMethodMask: ?BSTR,
                dwReason: u32,
                u64TraceHandle: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISystemAppEventData_Startup(self: *const T) HRESULT {
                return @as(*const ISystemAppEventData.VTable, @ptrCast(self.vtable)).Startup(@as(*const ISystemAppEventData, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISystemAppEventData_OnDataChanged(self: *const T, dwPID: u32, dwMask: u32, dwNumberSinks: u32, bstrDwMethodMask: ?BSTR, dwReason: u32, u64TraceHandle: u64) HRESULT {
                return @as(*const ISystemAppEventData.VTable, @ptrCast(self.vtable)).OnDataChanged(@as(*const ISystemAppEventData, @ptrCast(self)), dwPID, dwMask, dwNumberSinks, bstrDwMethodMask, dwReason, u64TraceHandle);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMtsEvents_Value = Guid.initString("bacedf4d-74ab-11d0-b162-00aa00ba3258");
pub const IID_IMtsEvents = &IID_IMtsEvents_Value;
pub const IMtsEvents = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PackageName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEvents,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEvents,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PackageGuid: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEvents,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEvents,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PostEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMtsEvents,
                vEvent: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMtsEvents,
                vEvent: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_FireEvents: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEvents,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEvents,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProcessID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMtsEvents,
                id: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMtsEvents,
                id: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEvents_get_PackageName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_PackageName(@as(*const IMtsEvents, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEvents_get_PackageGuid(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_PackageGuid(@as(*const IMtsEvents, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEvents_PostEvent(self: *const T, vEvent: ?*VARIANT) HRESULT {
                return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).PostEvent(@as(*const IMtsEvents, @ptrCast(self)), vEvent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEvents_get_FireEvents(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_FireEvents(@as(*const IMtsEvents, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEvents_GetProcessID(self: *const T, id: ?*i32) HRESULT {
                return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).GetProcessID(@as(*const IMtsEvents, @ptrCast(self)), id);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMtsEventInfo_Value = Guid.initString("d56c3dc1-8482-11d0-b170-00aa00ba3258");
pub const IID_IMtsEventInfo = &IID_IMtsEventInfo_Value;
pub const IMtsEventInfo = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Names: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEventInfo,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEventInfo,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEventInfo,
                sDisplayName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEventInfo,
                sDisplayName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EventID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEventInfo,
                sGuidEventID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEventInfo,
                sGuidEventID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEventInfo,
                lCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEventInfo,
                lCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Value: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsEventInfo,
                sKey: ?BSTR,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsEventInfo,
                sKey: ?BSTR,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEventInfo_get_Names(self: *const T, pUnk: ?*?*IUnknown) HRESULT {
                return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Names(@as(*const IMtsEventInfo, @ptrCast(self)), pUnk);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEventInfo_get_DisplayName(self: *const T, sDisplayName: ?*?BSTR) HRESULT {
                return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IMtsEventInfo, @ptrCast(self)), sDisplayName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEventInfo_get_EventID(self: *const T, sGuidEventID: ?*?BSTR) HRESULT {
                return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_EventID(@as(*const IMtsEventInfo, @ptrCast(self)), sGuidEventID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEventInfo_get_Count(self: *const T, lCount: ?*i32) HRESULT {
                return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IMtsEventInfo, @ptrCast(self)), lCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsEventInfo_get_Value(self: *const T, sKey: ?BSTR, pVal: ?*VARIANT) HRESULT {
                return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Value(@as(*const IMtsEventInfo, @ptrCast(self)), sKey, pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMTSLocator_Value = Guid.initString("d19b8bfd-7f88-11d0-b16e-00aa00ba3258");
pub const IID_IMTSLocator = &IID_IMTSLocator_Value;
pub const IMTSLocator = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetEventDispatcher: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSLocator,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSLocator,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSLocator_GetEventDispatcher(self: *const T, pUnk: ?*?*IUnknown) HRESULT {
                return @as(*const IMTSLocator.VTable, @ptrCast(self.vtable)).GetEventDispatcher(@as(*const IMTSLocator, @ptrCast(self)), pUnk);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMtsGrp_Value = Guid.initString("4b2e958c-0393-11d1-b1ab-00aa00ba3258");
pub const IID_IMtsGrp = &IID_IMtsGrp_Value;
pub const IMtsGrp = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMtsGrp,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMtsGrp,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Item: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMtsGrp,
                lIndex: i32,
                ppUnkDispatcher: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMtsGrp,
                lIndex: i32,
                ppUnkDispatcher: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Refresh: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMtsGrp,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMtsGrp,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsGrp_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IMtsGrp, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsGrp_Item(self: *const T, lIndex: i32, ppUnkDispatcher: ?*?*IUnknown) HRESULT {
                return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).Item(@as(*const IMtsGrp, @ptrCast(self)), lIndex, ppUnkDispatcher);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMtsGrp_Refresh(self: *const T) HRESULT {
                return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).Refresh(@as(*const IMtsGrp, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMessageMover_Value = Guid.initString("588a085a-b795-11d1-8054-00c04fc340ee");
pub const IID_IMessageMover = &IID_IMessageMover_Value;
pub const IMessageMover = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SourcePath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_SourcePath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestPath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_DestPath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CommitBatchSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_CommitBatchSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IMessageMover,
                newVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IMessageMover,
                newVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveMessages: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMessageMover,
                plMessagesMoved: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMessageMover,
                plMessagesMoved: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_get_SourcePath(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_SourcePath(@as(*const IMessageMover, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_put_SourcePath(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_SourcePath(@as(*const IMessageMover, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_get_DestPath(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_DestPath(@as(*const IMessageMover, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_put_DestPath(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_DestPath(@as(*const IMessageMover, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_get_CommitBatchSize(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_CommitBatchSize(@as(*const IMessageMover, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_put_CommitBatchSize(self: *const T, newVal: i32) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_CommitBatchSize(@as(*const IMessageMover, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMessageMover_MoveMessages(self: *const T, plMessagesMoved: ?*i32) HRESULT {
                return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).MoveMessages(@as(*const IMessageMover, @ptrCast(self)), plMessagesMoved);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IEventServerTrace_Value = Guid.initString("9a9f12b8-80af-47ab-a579-35ea57725370");
pub const IID_IEventServerTrace = &IID_IEventServerTrace_Value;
pub const IEventServerTrace = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        StartTraceGuid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEventServerTrace,
                bstrguidEvent: ?BSTR,
                bstrguidFilter: ?BSTR,
                lPidFilter: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEventServerTrace,
                bstrguidEvent: ?BSTR,
                bstrguidFilter: ?BSTR,
                lPidFilter: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        StopTraceGuid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEventServerTrace,
                bstrguidEvent: ?BSTR,
                bstrguidFilter: ?BSTR,
                lPidFilter: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEventServerTrace,
                bstrguidEvent: ?BSTR,
                bstrguidFilter: ?BSTR,
                lPidFilter: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnumTraceGuid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEventServerTrace,
                plCntGuids: ?*i32,
                pbstrGuidList: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEventServerTrace,
                plCntGuids: ?*i32,
                pbstrGuidList: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEventServerTrace_StartTraceGuid(self: *const T, bstrguidEvent: ?BSTR, bstrguidFilter: ?BSTR, lPidFilter: i32) HRESULT {
                return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).StartTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), bstrguidEvent, bstrguidFilter, lPidFilter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEventServerTrace_StopTraceGuid(self: *const T, bstrguidEvent: ?BSTR, bstrguidFilter: ?BSTR, lPidFilter: i32) HRESULT {
                return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).StopTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), bstrguidEvent, bstrguidFilter, lPidFilter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEventServerTrace_EnumTraceGuid(self: *const T, plCntGuids: ?*i32, pbstrGuidList: ?*?BSTR) HRESULT {
                return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).EnumTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), plCntGuids, pbstrGuidList);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const RECYCLE_INFO = extern struct {
    guidCombaseProcessIdentifier: Guid,
    ProcessStartTime: i64,
    dwRecycleLifetimeLimit: u32,
    dwRecycleMemoryLimit: u32,
    dwRecycleExpirationTimeout: u32,
};

pub const DUMPTYPE = enum(i32) {
    FULL = 0,
    MINI = 1,
    NONE = 2,
};
pub const DUMPTYPE_FULL = DUMPTYPE.FULL;
pub const DUMPTYPE_MINI = DUMPTYPE.MINI;
pub const DUMPTYPE_NONE = DUMPTYPE.NONE;

pub const HANG_INFO = extern struct {
    fAppHangMonitorEnabled: BOOL,
    fTerminateOnHang: BOOL,
    DumpType: DUMPTYPE,
    dwHangTimeout: u32,
    dwDumpCount: u32,
    dwInfoMsgCount: u32,
};

pub const COMPLUS_APPTYPE = enum(i32) {
    UNKNOWN = -1,
    SERVER = 1,
    LIBRARY = 0,
    SWC = 2,
};
pub const APPTYPE_UNKNOWN = COMPLUS_APPTYPE.UNKNOWN;
pub const APPTYPE_SERVER = COMPLUS_APPTYPE.SERVER;
pub const APPTYPE_LIBRARY = COMPLUS_APPTYPE.LIBRARY;
pub const APPTYPE_SWC = COMPLUS_APPTYPE.SWC;

pub const CAppStatistics = extern struct {
    m_cTotalCalls: u32,
    m_cTotalInstances: u32,
    m_cTotalClasses: u32,
    m_cCallsPerSecond: u32,
};

pub const CAppData = extern struct {
    m_idApp: u32,
    m_szAppGuid: [40]u16,
    m_dwAppProcessId: u32,
    m_AppStatistics: CAppStatistics,
};

pub const CCLSIDData = extern struct {
    m_clsid: Guid,
    m_cReferences: u32,
    m_cBound: u32,
    m_cPooled: u32,
    m_cInCall: u32,
    m_dwRespTime: u32,
    m_cCallsCompleted: u32,
    m_cCallsFailed: u32,
};

pub const CCLSIDData2 = extern struct {
    m_clsid: Guid,
    m_appid: Guid,
    m_partid: Guid,
    m_pwszAppName: ?PWSTR,
    m_pwszCtxName: ?PWSTR,
    m_eAppType: COMPLUS_APPTYPE,
    m_cReferences: u32,
    m_cBound: u32,
    m_cPooled: u32,
    m_cInCall: u32,
    m_dwRespTime: u32,
    m_cCallsCompleted: u32,
    m_cCallsFailed: u32,
};

pub const GetAppTrackerDataFlags = enum(i32) {
    PROCESS_EXE_NAME = 1,
    LIBRARY_APPS = 2,
    SWC = 4,
    CLASS_NAME = 8,
    APPLICATION_NAME = 16,
};
pub const GATD_INCLUDE_PROCESS_EXE_NAME = GetAppTrackerDataFlags.PROCESS_EXE_NAME;
pub const GATD_INCLUDE_LIBRARY_APPS = GetAppTrackerDataFlags.LIBRARY_APPS;
pub const GATD_INCLUDE_SWC = GetAppTrackerDataFlags.SWC;
pub const GATD_INCLUDE_CLASS_NAME = GetAppTrackerDataFlags.CLASS_NAME;
pub const GATD_INCLUDE_APPLICATION_NAME = GetAppTrackerDataFlags.APPLICATION_NAME;

pub const ApplicationProcessSummary = extern struct {
    PartitionIdPrimaryApplication: Guid,
    ApplicationIdPrimaryApplication: Guid,
    ApplicationInstanceId: Guid,
    ProcessId: u32,
    Type: COMPLUS_APPTYPE,
    ProcessExeName: ?PWSTR,
    IsService: BOOL,
    IsPaused: BOOL,
    IsRecycled: BOOL,
};

pub const ApplicationProcessStatistics = extern struct {
    NumCallsOutstanding: u32,
    NumTrackedComponents: u32,
    NumComponentInstances: u32,
    AvgCallsPerSecond: u32,
    Reserved1: u32,
    Reserved2: u32,
    Reserved3: u32,
    Reserved4: u32,
};

pub const ApplicationProcessRecycleInfo = extern struct {
    IsRecyclable: BOOL,
    IsRecycled: BOOL,
    TimeRecycled: FILETIME,
    TimeToTerminate: FILETIME,
    RecycleReasonCode: i32,
    IsPendingRecycle: BOOL,
    HasAutomaticLifetimeRecycling: BOOL,
    TimeForAutomaticRecycling: FILETIME,
    MemoryLimitInKB: u32,
    MemoryUsageInKBLastCheck: u32,
    ActivationLimit: u32,
    NumActivationsLastReported: u32,
    CallLimit: u32,
    NumCallsLastReported: u32,
};

pub const ApplicationSummary = extern struct {
    ApplicationInstanceId: Guid,
    PartitionId: Guid,
    ApplicationId: Guid,
    Type: COMPLUS_APPTYPE,
    ApplicationName: ?PWSTR,
    NumTrackedComponents: u32,
    NumComponentInstances: u32,
};

pub const ComponentSummary = extern struct {
    ApplicationInstanceId: Guid,
    PartitionId: Guid,
    ApplicationId: Guid,
    Clsid: Guid,
    ClassName: ?PWSTR,
    ApplicationName: ?PWSTR,
};

pub const ComponentStatistics = extern struct {
    NumInstances: u32,
    NumBoundReferences: u32,
    NumPooledObjects: u32,
    NumObjectsInCall: u32,
    AvgResponseTimeInMs: u32,
    NumCallsCompletedRecent: u32,
    NumCallsFailedRecent: u32,
    NumCallsCompletedTotal: u32,
    NumCallsFailedTotal: u32,
    Reserved1: u32,
    Reserved2: u32,
    Reserved3: u32,
    Reserved4: u32,
};

pub const ComponentHangMonitorInfo = extern struct {
    IsMonitored: BOOL,
    TerminateOnHang: BOOL,
    AvgCallThresholdInMs: u32,
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IGetAppTrackerData_Value = Guid.initString("507c3ac8-3e12-4cb0-9366-653d3e050638");
pub const IID_IGetAppTrackerData = &IID_IGetAppTrackerData_Value;
pub const IGetAppTrackerData = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetApplicationProcesses: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                PartitionId: ?*const Guid,
                ApplicationId: ?*const Guid,
                Flags: u32,
                NumApplicationProcesses: ?*u32,
                ApplicationProcesses: ?[*]?*ApplicationProcessSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                PartitionId: ?*const Guid,
                ApplicationId: ?*const Guid,
                Flags: u32,
                NumApplicationProcesses: ?*u32,
                ApplicationProcesses: ?[*]?*ApplicationProcessSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationProcessDetails: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                Flags: u32,
                Summary: ?*ApplicationProcessSummary,
                Statistics: ?*ApplicationProcessStatistics,
                RecycleInfo: ?*ApplicationProcessRecycleInfo,
                AnyComponentsHangMonitored: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                Flags: u32,
                Summary: ?*ApplicationProcessSummary,
                Statistics: ?*ApplicationProcessStatistics,
                RecycleInfo: ?*ApplicationProcessRecycleInfo,
                AnyComponentsHangMonitored: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationsInProcess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                PartitionId: ?*const Guid,
                Flags: u32,
                NumApplicationsInProcess: ?*u32,
                Applications: ?[*]?*ApplicationSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                PartitionId: ?*const Guid,
                Flags: u32,
                NumApplicationsInProcess: ?*u32,
                Applications: ?[*]?*ApplicationSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentsInProcess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                PartitionId: ?*const Guid,
                ApplicationId: ?*const Guid,
                Flags: u32,
                NumComponentsInProcess: ?*u32,
                Components: ?[*]?*ComponentSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                PartitionId: ?*const Guid,
                ApplicationId: ?*const Guid,
                Flags: u32,
                NumComponentsInProcess: ?*u32,
                Components: ?[*]?*ComponentSummary,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentDetails: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                Clsid: ?*const Guid,
                Flags: u32,
                Summary: ?*ComponentSummary,
                Statistics: ?*ComponentStatistics,
                HangMonitorInfo: ?*ComponentHangMonitorInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                ApplicationInstanceId: ?*const Guid,
                ProcessId: u32,
                Clsid: ?*const Guid,
                Flags: u32,
                Summary: ?*ComponentSummary,
                Statistics: ?*ComponentStatistics,
                HangMonitorInfo: ?*ComponentHangMonitorInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTrackerDataAsCollectionObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                TopLevelCollection: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                TopLevelCollection: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSuggestedPollingInterval: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetAppTrackerData,
                PollingIntervalInSeconds: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetAppTrackerData,
                PollingIntervalInSeconds: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetApplicationProcesses(self: *const T, PartitionId: ?*const Guid, ApplicationId: ?*const Guid, Flags: u32, NumApplicationProcesses: ?*u32, ApplicationProcesses: ?[*]?*ApplicationProcessSummary) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationProcesses(@as(*const IGetAppTrackerData, @ptrCast(self)), PartitionId, ApplicationId, Flags, NumApplicationProcesses, ApplicationProcesses);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetApplicationProcessDetails(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, Flags: u32, Summary: ?*ApplicationProcessSummary, Statistics: ?*ApplicationProcessStatistics, RecycleInfo: ?*ApplicationProcessRecycleInfo, AnyComponentsHangMonitored: ?*BOOL) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationProcessDetails(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, Flags, Summary, Statistics, RecycleInfo, AnyComponentsHangMonitored);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetApplicationsInProcess(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, PartitionId: ?*const Guid, Flags: u32, NumApplicationsInProcess: ?*u32, Applications: ?[*]?*ApplicationSummary) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationsInProcess(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, PartitionId, Flags, NumApplicationsInProcess, Applications);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetComponentsInProcess(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, PartitionId: ?*const Guid, ApplicationId: ?*const Guid, Flags: u32, NumComponentsInProcess: ?*u32, Components: ?[*]?*ComponentSummary) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetComponentsInProcess(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, PartitionId, ApplicationId, Flags, NumComponentsInProcess, Components);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetComponentDetails(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, Clsid: ?*const Guid, Flags: u32, Summary: ?*ComponentSummary, Statistics: ?*ComponentStatistics, HangMonitorInfo: ?*ComponentHangMonitorInfo) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetComponentDetails(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, Clsid, Flags, Summary, Statistics, HangMonitorInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetTrackerDataAsCollectionObject(self: *const T, TopLevelCollection: ?*?*IUnknown) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetTrackerDataAsCollectionObject(@as(*const IGetAppTrackerData, @ptrCast(self)), TopLevelCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetAppTrackerData_GetSuggestedPollingInterval(self: *const T, PollingIntervalInSeconds: ?*u32) HRESULT {
                return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetSuggestedPollingInterval(@as(*const IGetAppTrackerData, @ptrCast(self)), PollingIntervalInSeconds);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IDispenserManager_Value = Guid.initString("5cb31e10-2b5f-11cf-be10-00aa00a2fa25");
pub const IID_IDispenserManager = &IID_IDispenserManager_Value;
pub const IDispenserManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        RegisterDispenser: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserManager,
                __MIDL__IDispenserManager0000: ?*IDispenserDriver,
                szDispenserName: ?[*:0]const u16,
                __MIDL__IDispenserManager0001: ?*?*IHolder,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserManager,
                __MIDL__IDispenserManager0000: ?*IDispenserDriver,
                szDispenserName: ?[*:0]const u16,
                __MIDL__IDispenserManager0001: ?*?*IHolder,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserManager,
                __MIDL__IDispenserManager0002: ?*usize,
                __MIDL__IDispenserManager0003: ?*usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserManager,
                __MIDL__IDispenserManager0002: ?*usize,
                __MIDL__IDispenserManager0003: ?*usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserManager_RegisterDispenser(self: *const T, __MIDL__IDispenserManager0000: ?*IDispenserDriver, szDispenserName: ?[*:0]const u16, __MIDL__IDispenserManager0001: ?*?*IHolder) HRESULT {
                return @as(*const IDispenserManager.VTable, @ptrCast(self.vtable)).RegisterDispenser(@as(*const IDispenserManager, @ptrCast(self)), __MIDL__IDispenserManager0000, szDispenserName, __MIDL__IDispenserManager0001);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserManager_GetContext(self: *const T, __MIDL__IDispenserManager0002: ?*usize, __MIDL__IDispenserManager0003: ?*usize) HRESULT {
                return @as(*const IDispenserManager.VTable, @ptrCast(self.vtable)).GetContext(@as(*const IDispenserManager, @ptrCast(self)), __MIDL__IDispenserManager0002, __MIDL__IDispenserManager0003);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IHolder_Value = Guid.initString("bf6a1850-2b45-11cf-be10-00aa00a2fa25");
pub const IID_IHolder = &IID_IHolder_Value;
pub const IHolder = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AllocResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0000: usize,
                __MIDL__IHolder0001: ?*usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0000: usize,
                __MIDL__IHolder0001: ?*usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FreeResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0002: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0002: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TrackResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0003: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0003: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TrackResourceS: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0004: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0004: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UntrackResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0005: usize,
                __MIDL__IHolder0006: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0005: usize,
                __MIDL__IHolder0006: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UntrackResourceS: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0007: ?*u16,
                __MIDL__IHolder0008: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0007: ?*u16,
                __MIDL__IHolder0008: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestDestroyResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IHolder,
                __MIDL__IHolder0009: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IHolder,
                __MIDL__IHolder0009: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_AllocResource(self: *const T, __MIDL__IHolder0000: usize, __MIDL__IHolder0001: ?*usize) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).AllocResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0000, __MIDL__IHolder0001);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_FreeResource(self: *const T, __MIDL__IHolder0002: usize) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).FreeResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0002);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_TrackResource(self: *const T, __MIDL__IHolder0003: usize) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).TrackResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0003);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_TrackResourceS(self: *const T, __MIDL__IHolder0004: ?*u16) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).TrackResourceS(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0004);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_UntrackResource(self: *const T, __MIDL__IHolder0005: usize, __MIDL__IHolder0006: BOOL) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).UntrackResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0005, __MIDL__IHolder0006);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_UntrackResourceS(self: *const T, __MIDL__IHolder0007: ?*u16, __MIDL__IHolder0008: BOOL) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).UntrackResourceS(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0007, __MIDL__IHolder0008);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_Close(self: *const T) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).Close(@as(*const IHolder, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IHolder_RequestDestroyResource(self: *const T, __MIDL__IHolder0009: usize) HRESULT {
                return @as(*const IHolder.VTable, @ptrCast(self.vtable)).RequestDestroyResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0009);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IDispenserDriver_Value = Guid.initString("208b3651-2b48-11cf-be10-00aa00a2fa25");
pub const IID_IDispenserDriver = &IID_IDispenserDriver_Value;
pub const IDispenserDriver = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResTypId: usize,
                pResId: ?*usize,
                pSecsFreeBeforeDestroy: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResTypId: usize,
                pResId: ?*usize,
                pSecsFreeBeforeDestroy: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RateResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResTypId: usize,
                ResId: usize,
                fRequiresTransactionEnlistment: BOOL,
                pRating: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResTypId: usize,
                ResId: usize,
                fRequiresTransactionEnlistment: BOOL,
                pRating: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnlistResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResId: usize,
                TransId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResId: usize,
                TransId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ResetResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DestroyResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResId: usize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DestroyResourceS: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDispenserDriver,
                ResId: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDispenserDriver,
                ResId: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_CreateResource(self: *const T, ResTypId: usize, pResId: ?*usize, pSecsFreeBeforeDestroy: ?*i32) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).CreateResource(@as(*const IDispenserDriver, @ptrCast(self)), ResTypId, pResId, pSecsFreeBeforeDestroy);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_RateResource(self: *const T, ResTypId: usize, ResId: usize, fRequiresTransactionEnlistment: BOOL, pRating: ?*u32) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).RateResource(@as(*const IDispenserDriver, @ptrCast(self)), ResTypId, ResId, fRequiresTransactionEnlistment, pRating);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_EnlistResource(self: *const T, ResId: usize, TransId: usize) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).EnlistResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId, TransId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_ResetResource(self: *const T, ResId: usize) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).ResetResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_DestroyResource(self: *const T, ResId: usize) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).DestroyResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDispenserDriver_DestroyResourceS(self: *const T, ResId: ?*u16) HRESULT {
                return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).DestroyResourceS(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ITransactionProxy_Value = Guid.initString("02558374-df2e-4dae-bd6b-1d5c994f9bdc");
pub const IID_ITransactionProxy = &IID_ITransactionProxy_Value;
pub const ITransactionProxy = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Commit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                guid: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                guid: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Abort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Promote: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                pTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                pTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateVoter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                pTxAsync: ?*ITransactionVoterNotifyAsync2,
                ppBallot: ?*?*ITransactionVoterBallotAsync2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                pTxAsync: ?*ITransactionVoterNotifyAsync2,
                ppBallot: ?*?*ITransactionVoterBallotAsync2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIsolationLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                __MIDL__ITransactionProxy0000: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                __MIDL__ITransactionProxy0000: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIdentifier: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                pbstrIdentifier: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                pbstrIdentifier: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsReusable: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProxy,
                pfIsReusable: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProxy,
                pfIsReusable: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_Commit(self: *const T, guid: Guid) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionProxy, @ptrCast(self)), guid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_Abort(self: *const T) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionProxy, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_Promote(self: *const T, pTransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Promote(@as(*const ITransactionProxy, @ptrCast(self)), pTransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_CreateVoter(self: *const T, pTxAsync: ?*ITransactionVoterNotifyAsync2, ppBallot: ?*?*ITransactionVoterBallotAsync2) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).CreateVoter(@as(*const ITransactionProxy, @ptrCast(self)), pTxAsync, ppBallot);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_GetIsolationLevel(self: *const T, __MIDL__ITransactionProxy0000: ?*i32) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).GetIsolationLevel(@as(*const ITransactionProxy, @ptrCast(self)), __MIDL__ITransactionProxy0000);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_GetIdentifier(self: *const T, pbstrIdentifier: ?*Guid) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).GetIdentifier(@as(*const ITransactionProxy, @ptrCast(self)), pbstrIdentifier);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProxy_IsReusable(self: *const T, pfIsReusable: ?*BOOL) HRESULT {
                return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).IsReusable(@as(*const ITransactionProxy, @ptrCast(self)), pfIsReusable);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContextSecurityPerimeter_Value = Guid.initString("a7549a29-a7c4-42e1-8dc1-7e3d748dc24a");
pub const IID_IContextSecurityPerimeter = &IID_IContextSecurityPerimeter_Value;
pub const IContextSecurityPerimeter = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetPerimeterFlag: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextSecurityPerimeter,
                pFlag: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextSecurityPerimeter,
                pFlag: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPerimeterFlag: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextSecurityPerimeter,
                fFlag: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextSecurityPerimeter,
                fFlag: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextSecurityPerimeter_GetPerimeterFlag(self: *const T, pFlag: ?*BOOL) HRESULT {
                return @as(*const IContextSecurityPerimeter.VTable, @ptrCast(self.vtable)).GetPerimeterFlag(@as(*const IContextSecurityPerimeter, @ptrCast(self)), pFlag);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextSecurityPerimeter_SetPerimeterFlag(self: *const T, fFlag: BOOL) HRESULT {
                return @as(*const IContextSecurityPerimeter.VTable, @ptrCast(self.vtable)).SetPerimeterFlag(@as(*const IContextSecurityPerimeter, @ptrCast(self)), fFlag);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITxProxyHolder_Value = Guid.initString("13d86f31-0139-41af-bcad-c7d50435fe9f");
pub const IID_ITxProxyHolder = &IID_ITxProxyHolder_Value;
pub const ITxProxyHolder = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetIdentifier: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITxProxyHolder,
                pGuidLtx: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITxProxyHolder,
                pGuidLtx: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITxProxyHolder_GetIdentifier(self: *const T, pGuidLtx: ?*Guid) void {
                return @as(*const ITxProxyHolder.VTable, @ptrCast(self.vtable)).GetIdentifier(@as(*const ITxProxyHolder, @ptrCast(self)), pGuidLtx);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectContext_Value = Guid.initString("51372ae0-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IObjectContext = &IID_IObjectContext_Value;
pub const IObjectContext = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateInstance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
                rclsid: ?*const Guid,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DisableCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsInTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        IsSecurityEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IObjectContext,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        IsCallerInRole: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContext,
                bstrRole: ?BSTR,
                pfIsInRole: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContext,
                bstrRole: ?BSTR,
                pfIsInRole: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_CreateInstance(self: *const T, rclsid: ?*const Guid, riid: ?*const Guid, ppv: ?*?*anyopaque) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const IObjectContext, @ptrCast(self)), rclsid, riid, ppv);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_SetComplete(self: *const T) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).SetComplete(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_SetAbort(self: *const T) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).SetAbort(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_EnableCommit(self: *const T) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).EnableCommit(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_DisableCommit(self: *const T) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).DisableCommit(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_IsInTransaction(self: *const T) BOOL {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_IsSecurityEnabled(self: *const T) BOOL {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const IObjectContext, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pfIsInRole: ?*BOOL) HRESULT {
                return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const IObjectContext, @ptrCast(self)), bstrRole, pfIsInRole);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectControl_Value = Guid.initString("51372aec-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IObjectControl = &IID_IObjectControl_Value;
pub const IObjectControl = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Activate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Deactivate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        CanBePooled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectControl_Activate(self: *const T) HRESULT {
                return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).Activate(@as(*const IObjectControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectControl_Deactivate(self: *const T) void {
                return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).Deactivate(@as(*const IObjectControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectControl_CanBePooled(self: *const T) BOOL {
                return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).CanBePooled(@as(*const IObjectControl, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IEnumNames_Value = Guid.initString("51372af2-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IEnumNames = &IID_IEnumNames_Value;
pub const IEnumNames = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumNames,
                celt: u32,
                rgname: ?*?BSTR,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumNames,
                celt: u32,
                rgname: ?*?BSTR,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Skip: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumNames,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumNames,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumNames,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumNames,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumNames_Next(self: *const T, celt: u32, rgname: ?*?BSTR, pceltFetched: ?*u32) HRESULT {
                return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Next(@as(*const IEnumNames, @ptrCast(self)), celt, rgname, pceltFetched);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumNames_Skip(self: *const T, celt: u32) HRESULT {
                return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Skip(@as(*const IEnumNames, @ptrCast(self)), celt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumNames_Reset(self: *const T) HRESULT {
                return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Reset(@as(*const IEnumNames, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumNames_Clone(self: *const T, ppenum: ?*?*IEnumNames) HRESULT {
                return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Clone(@as(*const IEnumNames, @ptrCast(self)), ppenum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISecurityProperty_Value = Guid.initString("51372aea-cae7-11cf-be81-00aa00a2fa25");
pub const IID_ISecurityProperty = &IID_ISecurityProperty_Value;
pub const ISecurityProperty = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetDirectCreatorSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOriginalCreatorSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDirectCallerSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOriginalCallerSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityProperty,
                pSID: ?*?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReleaseSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISecurityProperty,
                pSID: ?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISecurityProperty,
                pSID: ?PSID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityProperty_GetDirectCreatorSID(self: *const T, pSID: ?*?PSID) HRESULT {
                return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCreatorSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityProperty_GetOriginalCreatorSID(self: *const T, pSID: ?*?PSID) HRESULT {
                return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCreatorSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityProperty_GetDirectCallerSID(self: *const T, pSID: ?*?PSID) HRESULT {
                return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCallerSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityProperty_GetOriginalCallerSID(self: *const T, pSID: ?*?PSID) HRESULT {
                return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCallerSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISecurityProperty_ReleaseSID(self: *const T, pSID: ?PSID) HRESULT {
                return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).ReleaseSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ObjectControl_Value = Guid.initString("7dc41850-0c31-11d0-8b79-00aa00b8a790");
pub const IID_ObjectControl = &IID_ObjectControl_Value;
pub const ObjectControl = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Activate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Deactivate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CanBePooled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ObjectControl,
                pbPoolable: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ObjectControl,
                pbPoolable: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectControl_Activate(self: *const T) HRESULT {
                return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).Activate(@as(*const ObjectControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectControl_Deactivate(self: *const T) HRESULT {
                return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).Deactivate(@as(*const ObjectControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ObjectControl_CanBePooled(self: *const T, pbPoolable: ?*i16) HRESULT {
                return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).CanBePooled(@as(*const ObjectControl, @ptrCast(self)), pbPoolable);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISharedProperty_Value = Guid.initString("2a005c01-a5de-11cf-9e66-00aa00a3f464");
pub const IID_ISharedProperty = &IID_ISharedProperty_Value;
pub const ISharedProperty = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Value: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedProperty,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedProperty,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Value: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedProperty,
                val: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedProperty,
                val: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedProperty_get_Value(self: *const T, pVal: ?*VARIANT) HRESULT {
                return @as(*const ISharedProperty.VTable, @ptrCast(self.vtable)).get_Value(@as(*const ISharedProperty, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedProperty_put_Value(self: *const T, val: VARIANT) HRESULT {
                return @as(*const ISharedProperty.VTable, @ptrCast(self.vtable)).put_Value(@as(*const ISharedProperty, @ptrCast(self)), val);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISharedPropertyGroup_Value = Guid.initString("2a005c07-a5de-11cf-9e66-00aa00a3f464");
pub const IID_ISharedPropertyGroup = &IID_ISharedPropertyGroup_Value;
pub const ISharedPropertyGroup = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        CreatePropertyByPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISharedPropertyGroup,
                Index: i32,
                fExists: ?*i16,
                ppProp: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISharedPropertyGroup,
                Index: i32,
                fExists: ?*i16,
                ppProp: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PropertyByPosition: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedPropertyGroup,
                Index: i32,
                ppProperty: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedPropertyGroup,
                Index: i32,
                ppProperty: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISharedPropertyGroup,
                Name: ?BSTR,
                fExists: ?*i16,
                ppProp: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISharedPropertyGroup,
                Name: ?BSTR,
                fExists: ?*i16,
                ppProp: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Property: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedPropertyGroup,
                Name: ?BSTR,
                ppProperty: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedPropertyGroup,
                Name: ?BSTR,
                ppProperty: ?*?*ISharedProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroup_CreatePropertyByPosition(self: *const T, Index: i32, fExists: ?*i16, ppProp: ?*?*ISharedProperty) HRESULT {
                return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).CreatePropertyByPosition(@as(*const ISharedPropertyGroup, @ptrCast(self)), Index, fExists, ppProp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroup_get_PropertyByPosition(self: *const T, Index: i32, ppProperty: ?*?*ISharedProperty) HRESULT {
                return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).get_PropertyByPosition(@as(*const ISharedPropertyGroup, @ptrCast(self)), Index, ppProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroup_CreateProperty(self: *const T, Name: ?BSTR, fExists: ?*i16, ppProp: ?*?*ISharedProperty) HRESULT {
                return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).CreateProperty(@as(*const ISharedPropertyGroup, @ptrCast(self)), Name, fExists, ppProp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroup_get_Property(self: *const T, Name: ?BSTR, ppProperty: ?*?*ISharedProperty) HRESULT {
                return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).get_Property(@as(*const ISharedPropertyGroup, @ptrCast(self)), Name, ppProperty);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISharedPropertyGroupManager_Value = Guid.initString("2a005c0d-a5de-11cf-9e66-00aa00a3f464");
pub const IID_ISharedPropertyGroupManager = &IID_ISharedPropertyGroupManager_Value;
pub const ISharedPropertyGroupManager = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        CreatePropertyGroup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISharedPropertyGroupManager,
                Name: ?BSTR,
                dwIsoMode: ?*i32,
                dwRelMode: ?*i32,
                fExists: ?*i16,
                ppGroup: ?*?*ISharedPropertyGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISharedPropertyGroupManager,
                Name: ?BSTR,
                dwIsoMode: ?*i32,
                dwRelMode: ?*i32,
                fExists: ?*i16,
                ppGroup: ?*?*ISharedPropertyGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Group: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedPropertyGroupManager,
                Name: ?BSTR,
                ppGroup: ?*?*ISharedPropertyGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedPropertyGroupManager,
                Name: ?BSTR,
                ppGroup: ?*?*ISharedPropertyGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ISharedPropertyGroupManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ISharedPropertyGroupManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroupManager_CreatePropertyGroup(self: *const T, Name: ?BSTR, dwIsoMode: ?*i32, dwRelMode: ?*i32, fExists: ?*i16, ppGroup: ?*?*ISharedPropertyGroup) HRESULT {
                return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).CreatePropertyGroup(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), Name, dwIsoMode, dwRelMode, fExists, ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroupManager_get_Group(self: *const T, Name: ?BSTR, ppGroup: ?*?*ISharedPropertyGroup) HRESULT {
                return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).get_Group(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), Name, ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISharedPropertyGroupManager_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), retval);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectConstruct_Value = Guid.initString("41c4f8b3-7439-11d2-98cb-00c04f8ee1c4");
pub const IID_IObjectConstruct = &IID_IObjectConstruct_Value;
pub const IObjectConstruct = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Construct: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectConstruct,
                pCtorObj: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectConstruct,
                pCtorObj: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectConstruct_Construct(self: *const T, pCtorObj: ?*IDispatch) HRESULT {
                return @as(*const IObjectConstruct.VTable, @ptrCast(self.vtable)).Construct(@as(*const IObjectConstruct, @ptrCast(self)), pCtorObj);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectConstructString_Value = Guid.initString("41c4f8b2-7439-11d2-98cb-00c04f8ee1c4");
pub const IID_IObjectConstructString = &IID_IObjectConstructString_Value;
pub const IObjectConstructString = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ConstructString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IObjectConstructString,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IObjectConstructString,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectConstructString_get_ConstructString(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IObjectConstructString.VTable, @ptrCast(self.vtable)).get_ConstructString(@as(*const IObjectConstructString, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectContextActivity_Value = Guid.initString("51372afc-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IObjectContextActivity = &IID_IObjectContextActivity_Value;
pub const IObjectContextActivity = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetActivityId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextActivity,
                pGUID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextActivity,
                pGUID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextActivity_GetActivityId(self: *const T, pGUID: ?*Guid) HRESULT {
                return @as(*const IObjectContextActivity.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const IObjectContextActivity, @ptrCast(self)), pGUID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectContextInfo_Value = Guid.initString("75b52ddb-e8ed-11d1-93ad-00aa00ba3258");
pub const IID_IObjectContextInfo = &IID_IObjectContextInfo_Value;
pub const IObjectContextInfo = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        IsInTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IObjectContextInfo,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        GetTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo,
                pptrans: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo,
                pptrans: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetActivityId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo,
                pGUID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo,
                pGUID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetContextId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo_IsInTransaction(self: *const T) BOOL {
                return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const IObjectContextInfo, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo_GetTransaction(self: *const T, pptrans: ?*?*IUnknown) HRESULT {
                return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const IObjectContextInfo, @ptrCast(self)), pptrans);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo_GetTransactionId(self: *const T, pGuid: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetTransactionId(@as(*const IObjectContextInfo, @ptrCast(self)), pGuid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo_GetActivityId(self: *const T, pGUID: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const IObjectContextInfo, @ptrCast(self)), pGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo_GetContextId(self: *const T, pGuid: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetContextId(@as(*const IObjectContextInfo, @ptrCast(self)), pGuid);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IObjectContextInfo2_Value = Guid.initString("594be71a-4bc4-438b-9197-cfd176248b09");
pub const IID_IObjectContextInfo2 = &IID_IObjectContextInfo2_Value;
pub const IObjectContextInfo2 = extern struct {
    pub const VTable = extern struct {
        base: IObjectContextInfo.VTable,
        GetPartitionId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetApplicationInstanceId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextInfo2,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IObjectContextInfo.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo2_GetPartitionId(self: *const T, pGuid: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetPartitionId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo2_GetApplicationId(self: *const T, pGuid: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextInfo2_GetApplicationInstanceId(self: *const T, pGuid: ?*Guid) HRESULT {
                return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ITransactionStatus_Value = Guid.initString("61f589e8-3724-4898-a0a4-664ae9e1d1b4");
pub const IID_ITransactionStatus = &IID_ITransactionStatus_Value;
pub const ITransactionStatus = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetTransactionStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionStatus,
                hrStatus: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionStatus,
                hrStatus: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionStatus,
                pHrStatus: ?*HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionStatus,
                pHrStatus: ?*HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionStatus_SetTransactionStatus(self: *const T, hrStatus: HRESULT) HRESULT {
                return @as(*const ITransactionStatus.VTable, @ptrCast(self.vtable)).SetTransactionStatus(@as(*const ITransactionStatus, @ptrCast(self)), hrStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionStatus_GetTransactionStatus(self: *const T, pHrStatus: ?*HRESULT) HRESULT {
                return @as(*const ITransactionStatus.VTable, @ptrCast(self.vtable)).GetTransactionStatus(@as(*const ITransactionStatus, @ptrCast(self)), pHrStatus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IObjectContextTip_Value = Guid.initString("92fd41ca-bad9-11d2-9a2d-00c04f797bc9");
pub const IID_IObjectContextTip = &IID_IObjectContextTip_Value;
pub const IObjectContextTip = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetTipUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjectContextTip,
                pTipUrl: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IObjectContextTip,
                pTipUrl: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjectContextTip_GetTipUrl(self: *const T, pTipUrl: ?*?BSTR) HRESULT {
                return @as(*const IObjectContextTip.VTable, @ptrCast(self.vtable)).GetTipUrl(@as(*const IObjectContextTip, @ptrCast(self)), pTipUrl);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IPlaybackControl_Value = Guid.initString("51372afd-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IPlaybackControl = &IID_IPlaybackControl_Value;
pub const IPlaybackControl = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FinalClientRetry: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPlaybackControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPlaybackControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FinalServerRetry: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPlaybackControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPlaybackControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPlaybackControl_FinalClientRetry(self: *const T) HRESULT {
                return @as(*const IPlaybackControl.VTable, @ptrCast(self.vtable)).FinalClientRetry(@as(*const IPlaybackControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPlaybackControl_FinalServerRetry(self: *const T) HRESULT {
                return @as(*const IPlaybackControl.VTable, @ptrCast(self.vtable)).FinalServerRetry(@as(*const IPlaybackControl, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IGetContextProperties_Value = Guid.initString("51372af4-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IGetContextProperties = &IID_IGetContextProperties_Value;
pub const IGetContextProperties = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Count: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetContextProperties,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetContextProperties,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetContextProperties,
                name: ?BSTR,
                pProperty: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetContextProperties,
                name: ?BSTR,
                pProperty: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnumNames: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetContextProperties,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetContextProperties,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetContextProperties_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).Count(@as(*const IGetContextProperties, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetContextProperties_GetProperty(self: *const T, name: ?BSTR, pProperty: ?*VARIANT) HRESULT {
                return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IGetContextProperties, @ptrCast(self)), name, pProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGetContextProperties_EnumNames(self: *const T, ppenum: ?*?*IEnumNames) HRESULT {
                return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).EnumNames(@as(*const IGetContextProperties, @ptrCast(self)), ppenum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const TransactionVote = enum(i32) {
    Commit = 0,
    Abort = 1,
};
pub const TxCommit = TransactionVote.Commit;
pub const TxAbort = TransactionVote.Abort;

// TODO: this type is limited to platform 'windows5.0'
const IID_IContextState_Value = Guid.initString("3c05e54b-a42a-11d2-afc4-00c04f8ee1c4");
pub const IID_IContextState = &IID_IContextState_Value;
pub const IContextState = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetDeactivateOnReturn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextState,
                bDeactivate: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextState,
                bDeactivate: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeactivateOnReturn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextState,
                pbDeactivate: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextState,
                pbDeactivate: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMyTransactionVote: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextState,
                txVote: TransactionVote,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextState,
                txVote: TransactionVote,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMyTransactionVote: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextState,
                ptxVote: ?*TransactionVote,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextState,
                ptxVote: ?*TransactionVote,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextState_SetDeactivateOnReturn(self: *const T, bDeactivate: i16) HRESULT {
                return @as(*const IContextState.VTable, @ptrCast(self.vtable)).SetDeactivateOnReturn(@as(*const IContextState, @ptrCast(self)), bDeactivate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextState_GetDeactivateOnReturn(self: *const T, pbDeactivate: ?*i16) HRESULT {
                return @as(*const IContextState.VTable, @ptrCast(self.vtable)).GetDeactivateOnReturn(@as(*const IContextState, @ptrCast(self)), pbDeactivate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextState_SetMyTransactionVote(self: *const T, txVote: TransactionVote) HRESULT {
                return @as(*const IContextState.VTable, @ptrCast(self.vtable)).SetMyTransactionVote(@as(*const IContextState, @ptrCast(self)), txVote);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextState_GetMyTransactionVote(self: *const T, ptxVote: ?*TransactionVote) HRESULT {
                return @as(*const IContextState.VTable, @ptrCast(self.vtable)).GetMyTransactionVote(@as(*const IContextState, @ptrCast(self)), ptxVote);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IPoolManager_Value = Guid.initString("0a469861-5a91-43a0-99b6-d5e179bb0631");
pub const IID_IPoolManager = &IID_IPoolManager_Value;
pub const IPoolManager = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        ShutdownPool: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPoolManager,
                CLSIDOrProgID: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPoolManager,
                CLSIDOrProgID: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPoolManager_ShutdownPool(self: *const T, CLSIDOrProgID: ?BSTR) HRESULT {
                return @as(*const IPoolManager.VTable, @ptrCast(self.vtable)).ShutdownPool(@as(*const IPoolManager, @ptrCast(self)), CLSIDOrProgID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISelectCOMLBServer_Value = Guid.initString("dcf443f4-3f8a-4872-b9f0-369a796d12d6");
pub const IID_ISelectCOMLBServer = &IID_ISelectCOMLBServer_Value;
pub const ISelectCOMLBServer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Init: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISelectCOMLBServer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISelectCOMLBServer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLBServer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISelectCOMLBServer,
                pUnk: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISelectCOMLBServer,
                pUnk: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISelectCOMLBServer_Init(self: *const T) HRESULT {
                return @as(*const ISelectCOMLBServer.VTable, @ptrCast(self.vtable)).Init(@as(*const ISelectCOMLBServer, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISelectCOMLBServer_GetLBServer(self: *const T, pUnk: ?*IUnknown) HRESULT {
                return @as(*const ISelectCOMLBServer.VTable, @ptrCast(self.vtable)).GetLBServer(@as(*const ISelectCOMLBServer, @ptrCast(self)), pUnk);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICOMLBArguments_Value = Guid.initString("3a0f150f-8ee5-4b94-b40e-aef2f9e42ed2");
pub const IID_ICOMLBArguments = &IID_ICOMLBArguments_Value;
pub const ICOMLBArguments = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCLSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMLBArguments,
                pCLSID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMLBArguments,
                pCLSID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetCLSID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMLBArguments,
                pCLSID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMLBArguments,
                pCLSID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMachineName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMLBArguments,
                cchSvr: u32,
                szServerName: [*:0]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMLBArguments,
                cchSvr: u32,
                szServerName: [*:0]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMachineName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICOMLBArguments,
                cchSvr: u32,
                szServerName: [*:0]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICOMLBArguments,
                cchSvr: u32,
                szServerName: [*:0]u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMLBArguments_GetCLSID(self: *const T, pCLSID: ?*Guid) HRESULT {
                return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).GetCLSID(@as(*const ICOMLBArguments, @ptrCast(self)), pCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMLBArguments_SetCLSID(self: *const T, pCLSID: ?*Guid) HRESULT {
                return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).SetCLSID(@as(*const ICOMLBArguments, @ptrCast(self)), pCLSID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMLBArguments_GetMachineName(self: *const T, cchSvr: u32, szServerName: [*:0]u16) HRESULT {
                return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).GetMachineName(@as(*const ICOMLBArguments, @ptrCast(self)), cchSvr, szServerName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICOMLBArguments_SetMachineName(self: *const T, cchSvr: u32, szServerName: [*:0]u16) HRESULT {
                return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).SetMachineName(@as(*const ICOMLBArguments, @ptrCast(self)), cchSvr, szServerName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmLogControl_Value = Guid.initString("a0e174b3-d26e-11d2-8f84-00805fc7bcd9");
pub const IID_ICrmLogControl = &IID_ICrmLogControl_Value;
pub const ICrmLogControl = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TransactionUOW: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmLogControl,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmLogControl,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RegisterCompensator: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
                lpcwstrProgIdCompensator: ?[*:0]const u16,
                lpcwstrDescription: ?[*:0]const u16,
                lCrmRegFlags: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
                lpcwstrProgIdCompensator: ?[*:0]const u16,
                lpcwstrDescription: ?[*:0]const u16,
                lCrmRegFlags: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteLogRecordVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
                pLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
                pLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ForceLog: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ForgetLogRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ForceTransactionToAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteLogRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmLogControl,
                rgBlob: [*]BLOB,
                cBlob: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmLogControl,
                rgBlob: [*]BLOB,
                cBlob: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_get_TransactionUOW(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).get_TransactionUOW(@as(*const ICrmLogControl, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_RegisterCompensator(self: *const T, lpcwstrProgIdCompensator: ?[*:0]const u16, lpcwstrDescription: ?[*:0]const u16, lCrmRegFlags: i32) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).RegisterCompensator(@as(*const ICrmLogControl, @ptrCast(self)), lpcwstrProgIdCompensator, lpcwstrDescription, lCrmRegFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_WriteLogRecordVariants(self: *const T, pLogRecord: ?*VARIANT) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).WriteLogRecordVariants(@as(*const ICrmLogControl, @ptrCast(self)), pLogRecord);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_ForceLog(self: *const T) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForceLog(@as(*const ICrmLogControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_ForgetLogRecord(self: *const T) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForgetLogRecord(@as(*const ICrmLogControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_ForceTransactionToAbort(self: *const T) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForceTransactionToAbort(@as(*const ICrmLogControl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmLogControl_WriteLogRecord(self: *const T, rgBlob: [*]BLOB, cBlob: u32) HRESULT {
                return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).WriteLogRecord(@as(*const ICrmLogControl, @ptrCast(self)), rgBlob, cBlob);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmCompensatorVariants_Value = Guid.initString("f0baf8e4-7804-11d1-82e9-00a0c91eede9");
pub const IID_ICrmCompensatorVariants = &IID_ICrmCompensatorVariants_Value;
pub const ICrmCompensatorVariants = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetLogControlVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                pLogControl: ?*ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                pLogControl: ?*ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginPrepareVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PrepareRecordVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndPrepareVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                pbOkToPrepare: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                pbOkToPrepare: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginCommitVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                bRecovery: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                bRecovery: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitRecordVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndCommitVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginAbortVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                bRecovery: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                bRecovery: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortRecordVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
                pLogRecord: ?*VARIANT,
                pbForget: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndAbortVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensatorVariants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_SetLogControlVariants(self: *const T, pLogControl: ?*ICrmLogControl) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).SetLogControlVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogControl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_BeginPrepareVariants(self: *const T) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginPrepareVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_PrepareRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).PrepareRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_EndPrepareVariants(self: *const T, pbOkToPrepare: ?*i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndPrepareVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pbOkToPrepare);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_BeginCommitVariants(self: *const T, bRecovery: i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginCommitVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), bRecovery);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_CommitRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).CommitRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_EndCommitVariants(self: *const T) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndCommitVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_BeginAbortVariants(self: *const T, bRecovery: i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginAbortVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), bRecovery);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_AbortRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).AbortRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensatorVariants_EndAbortVariants(self: *const T) HRESULT {
                return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndAbortVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const CrmLogRecordRead = extern struct {
    dwCrmFlags: u32,
    dwSequenceNumber: u32,
    blobUserData: BLOB,
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmCompensator_Value = Guid.initString("bbc01830-8d3b-11d1-82ec-00a0c91eede9");
pub const IID_ICrmCompensator = &IID_ICrmCompensator_Value;
pub const ICrmCompensator = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetLogControl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                pLogControl: ?*ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                pLogControl: ?*ICrmLogControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginPrepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PrepareRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndPrepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                pfOkToPrepare: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                pfOkToPrepare: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                fRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                fRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                fRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                fRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
                crmLogRec: CrmLogRecordRead,
                pfForget: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndAbort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmCompensator,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_SetLogControl(self: *const T, pLogControl: ?*ICrmLogControl) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).SetLogControl(@as(*const ICrmCompensator, @ptrCast(self)), pLogControl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_BeginPrepare(self: *const T) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginPrepare(@as(*const ICrmCompensator, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_PrepareRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).PrepareRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_EndPrepare(self: *const T, pfOkToPrepare: ?*BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndPrepare(@as(*const ICrmCompensator, @ptrCast(self)), pfOkToPrepare);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_BeginCommit(self: *const T, fRecovery: BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginCommit(@as(*const ICrmCompensator, @ptrCast(self)), fRecovery);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_CommitRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).CommitRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_EndCommit(self: *const T) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndCommit(@as(*const ICrmCompensator, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_BeginAbort(self: *const T, fRecovery: BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginAbort(@as(*const ICrmCompensator, @ptrCast(self)), fRecovery);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_AbortRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).AbortRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmCompensator_EndAbort(self: *const T) HRESULT {
                return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndAbort(@as(*const ICrmCompensator, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const CrmTransactionState = enum(i32) {
    Active = 0,
    Committed = 1,
    Aborted = 2,
    Indoubt = 3,
};
pub const TxState_Active = CrmTransactionState.Active;
pub const TxState_Committed = CrmTransactionState.Committed;
pub const TxState_Aborted = CrmTransactionState.Aborted;
pub const TxState_Indoubt = CrmTransactionState.Indoubt;

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmMonitorLogRecords_Value = Guid.initString("70c8e441-c7ed-11d1-82fb-00a0c91eede9");
pub const IID_ICrmMonitorLogRecords = &IID_ICrmMonitorLogRecords_Value;
pub const ICrmMonitorLogRecords = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TransactionState: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*CrmTransactionState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*CrmTransactionState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StructuredRecords: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmMonitorLogRecords,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLogRecord: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorLogRecords,
                dwIndex: u32,
                pCrmLogRec: ?*CrmLogRecordRead,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorLogRecords,
                dwIndex: u32,
                pCrmLogRec: ?*CrmLogRecordRead,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLogRecordVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorLogRecords,
                IndexNumber: VARIANT,
                pLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorLogRecords,
                IndexNumber: VARIANT,
                pLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorLogRecords_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorLogRecords_get_TransactionState(self: *const T, pVal: ?*CrmTransactionState) HRESULT {
                return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_TransactionState(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorLogRecords_get_StructuredRecords(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_StructuredRecords(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorLogRecords_GetLogRecord(self: *const T, dwIndex: u32, pCrmLogRec: ?*CrmLogRecordRead) HRESULT {
                return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).GetLogRecord(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), dwIndex, pCrmLogRec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorLogRecords_GetLogRecordVariants(self: *const T, IndexNumber: VARIANT, pLogRecord: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).GetLogRecordVariants(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), IndexNumber, pLogRecord);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmMonitorClerks_Value = Guid.initString("70c8e442-c7ed-11d1-82fb-00a0c91eede9");
pub const IID_ICrmMonitorClerks = &IID_ICrmMonitorClerks_Value;
pub const ICrmMonitorClerks = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Item: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                pVal: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmMonitorClerks,
                pVal: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const ICrmMonitorClerks,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ProgIdCompensator: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Description: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TransactionUOW: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ActivityId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitorClerks,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_Item(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).Item(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_get__NewEnum(self: *const T, pVal: ?*?*IUnknown) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ICrmMonitorClerks, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICrmMonitorClerks, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_ProgIdCompensator(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).ProgIdCompensator(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_Description(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).Description(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_TransactionUOW(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).TransactionUOW(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitorClerks_ActivityId(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).ActivityId(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmMonitor_Value = Guid.initString("70c8e443-c7ed-11d1-82fb-00a0c91eede9");
pub const IID_ICrmMonitor = &IID_ICrmMonitor_Value;
pub const ICrmMonitor = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetClerks: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitor,
                pClerks: ?*?*ICrmMonitorClerks,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitor,
                pClerks: ?*?*ICrmMonitorClerks,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HoldClerk: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmMonitor,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmMonitor,
                Index: VARIANT,
                pItem: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitor_GetClerks(self: *const T, pClerks: ?*?*ICrmMonitorClerks) HRESULT {
                return @as(*const ICrmMonitor.VTable, @ptrCast(self.vtable)).GetClerks(@as(*const ICrmMonitor, @ptrCast(self)), pClerks);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmMonitor_HoldClerk(self: *const T, Index: VARIANT, pItem: ?*VARIANT) HRESULT {
                return @as(*const ICrmMonitor.VTable, @ptrCast(self.vtable)).HoldClerk(@as(*const ICrmMonitor, @ptrCast(self)), Index, pItem);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ICrmFormatLogRecords_Value = Guid.initString("9c51d821-c98b-11d1-82fb-00a0c91eede9");
pub const IID_ICrmFormatLogRecords = &IID_ICrmFormatLogRecords_Value;
pub const ICrmFormatLogRecords = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetColumnCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmFormatLogRecords,
                plColumnCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmFormatLogRecords,
                plColumnCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetColumnHeaders: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmFormatLogRecords,
                pHeaders: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmFormatLogRecords,
                pHeaders: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetColumn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmFormatLogRecords,
                CrmLogRec: CrmLogRecordRead,
                pFormattedLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmFormatLogRecords,
                CrmLogRec: CrmLogRecordRead,
                pFormattedLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetColumnVariants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICrmFormatLogRecords,
                LogRecord: VARIANT,
                pFormattedLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICrmFormatLogRecords,
                LogRecord: VARIANT,
                pFormattedLogRecord: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmFormatLogRecords_GetColumnCount(self: *const T, plColumnCount: ?*i32) HRESULT {
                return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnCount(@as(*const ICrmFormatLogRecords, @ptrCast(self)), plColumnCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmFormatLogRecords_GetColumnHeaders(self: *const T, pHeaders: ?*VARIANT) HRESULT {
                return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnHeaders(@as(*const ICrmFormatLogRecords, @ptrCast(self)), pHeaders);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmFormatLogRecords_GetColumn(self: *const T, CrmLogRec: CrmLogRecordRead, pFormattedLogRecord: ?*VARIANT) HRESULT {
                return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumn(@as(*const ICrmFormatLogRecords, @ptrCast(self)), CrmLogRec, pFormattedLogRecord);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICrmFormatLogRecords_GetColumnVariants(self: *const T, LogRecord: VARIANT, pFormattedLogRecord: ?*VARIANT) HRESULT {
                return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnVariants(@as(*const ICrmFormatLogRecords, @ptrCast(self)), LogRecord, pFormattedLogRecord);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const CSC_InheritanceConfig = enum(i32) {
    nherit = 0,
    gnore = 1,
};
pub const CSC_Inherit = CSC_InheritanceConfig.nherit;
pub const CSC_Ignore = CSC_InheritanceConfig.gnore;

pub const CSC_ThreadPool = enum(i32) {
    ThreadPoolNone = 0,
    ThreadPoolInherit = 1,
    STAThreadPool = 2,
    MTAThreadPool = 3,
};
pub const CSC_ThreadPoolNone = CSC_ThreadPool.ThreadPoolNone;
pub const CSC_ThreadPoolInherit = CSC_ThreadPool.ThreadPoolInherit;
pub const CSC_STAThreadPool = CSC_ThreadPool.STAThreadPool;
pub const CSC_MTAThreadPool = CSC_ThreadPool.MTAThreadPool;

pub const CSC_Binding = enum(i32) {
    NoBinding = 0,
    BindToPoolThread = 1,
};
pub const CSC_NoBinding = CSC_Binding.NoBinding;
pub const CSC_BindToPoolThread = CSC_Binding.BindToPoolThread;

pub const CSC_TransactionConfig = enum(i32) {
    NoTransaction = 0,
    IfContainerIsTransactional = 1,
    CreateTransactionIfNecessary = 2,
    NewTransaction = 3,
};
pub const CSC_NoTransaction = CSC_TransactionConfig.NoTransaction;
pub const CSC_IfContainerIsTransactional = CSC_TransactionConfig.IfContainerIsTransactional;
pub const CSC_CreateTransactionIfNecessary = CSC_TransactionConfig.CreateTransactionIfNecessary;
pub const CSC_NewTransaction = CSC_TransactionConfig.NewTransaction;

pub const CSC_SynchronizationConfig = enum(i32) {
    NoSynchronization = 0,
    IfContainerIsSynchronized = 1,
    NewSynchronizationIfNecessary = 2,
    NewSynchronization = 3,
};
pub const CSC_NoSynchronization = CSC_SynchronizationConfig.NoSynchronization;
pub const CSC_IfContainerIsSynchronized = CSC_SynchronizationConfig.IfContainerIsSynchronized;
pub const CSC_NewSynchronizationIfNecessary = CSC_SynchronizationConfig.NewSynchronizationIfNecessary;
pub const CSC_NewSynchronization = CSC_SynchronizationConfig.NewSynchronization;

pub const CSC_TrackerConfig = enum(i32) {
    DontUseTracker = 0,
    UseTracker = 1,
};
pub const CSC_DontUseTracker = CSC_TrackerConfig.DontUseTracker;
pub const CSC_UseTracker = CSC_TrackerConfig.UseTracker;

pub const CSC_PartitionConfig = enum(i32) {
    NoPartition = 0,
    InheritPartition = 1,
    NewPartition = 2,
};
pub const CSC_NoPartition = CSC_PartitionConfig.NoPartition;
pub const CSC_InheritPartition = CSC_PartitionConfig.InheritPartition;
pub const CSC_NewPartition = CSC_PartitionConfig.NewPartition;

pub const CSC_IISIntrinsicsConfig = enum(i32) {
    NoIISIntrinsics = 0,
    InheritIISIntrinsics = 1,
};
pub const CSC_NoIISIntrinsics = CSC_IISIntrinsicsConfig.NoIISIntrinsics;
pub const CSC_InheritIISIntrinsics = CSC_IISIntrinsicsConfig.InheritIISIntrinsics;

pub const CSC_COMTIIntrinsicsConfig = enum(i32) {
    NoCOMTIIntrinsics = 0,
    InheritCOMTIIntrinsics = 1,
};
pub const CSC_NoCOMTIIntrinsics = CSC_COMTIIntrinsicsConfig.NoCOMTIIntrinsics;
pub const CSC_InheritCOMTIIntrinsics = CSC_COMTIIntrinsicsConfig.InheritCOMTIIntrinsics;

pub const CSC_SxsConfig = enum(i32) {
    NoSxs = 0,
    InheritSxs = 1,
    NewSxs = 2,
};
pub const CSC_NoSxs = CSC_SxsConfig.NoSxs;
pub const CSC_InheritSxs = CSC_SxsConfig.InheritSxs;
pub const CSC_NewSxs = CSC_SxsConfig.NewSxs;

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceIISIntrinsicsConfig_Value = Guid.initString("1a0cf920-d452-46f4-bc36-48118d54ea52");
pub const IID_IServiceIISIntrinsicsConfig = &IID_IServiceIISIntrinsicsConfig_Value;
pub const IServiceIISIntrinsicsConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        IISIntrinsicsConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceIISIntrinsicsConfig,
                iisIntrinsicsConfig: CSC_IISIntrinsicsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceIISIntrinsicsConfig,
                iisIntrinsicsConfig: CSC_IISIntrinsicsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceIISIntrinsicsConfig_IISIntrinsicsConfig(self: *const T, iisIntrinsicsConfig: CSC_IISIntrinsicsConfig) HRESULT {
                return @as(*const IServiceIISIntrinsicsConfig.VTable, @ptrCast(self.vtable)).IISIntrinsicsConfig(@as(*const IServiceIISIntrinsicsConfig, @ptrCast(self)), iisIntrinsicsConfig);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceComTIIntrinsicsConfig_Value = Guid.initString("09e6831e-04e1-4ed4-9d0f-e8b168bafeaf");
pub const IID_IServiceComTIIntrinsicsConfig = &IID_IServiceComTIIntrinsicsConfig_Value;
pub const IServiceComTIIntrinsicsConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ComTIIntrinsicsConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceComTIIntrinsicsConfig,
                comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceComTIIntrinsicsConfig,
                comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceComTIIntrinsicsConfig_ComTIIntrinsicsConfig(self: *const T, comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig) HRESULT {
                return @as(*const IServiceComTIIntrinsicsConfig.VTable, @ptrCast(self.vtable)).ComTIIntrinsicsConfig(@as(*const IServiceComTIIntrinsicsConfig, @ptrCast(self)), comtiIntrinsicsConfig);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceSxsConfig_Value = Guid.initString("c7cd7379-f3f2-4634-811b-703281d73e08");
pub const IID_IServiceSxsConfig = &IID_IServiceSxsConfig_Value;
pub const IServiceSxsConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SxsConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceSxsConfig,
                scsConfig: CSC_SxsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceSxsConfig,
                scsConfig: CSC_SxsConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SxsName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceSxsConfig,
                szSxsName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceSxsConfig,
                szSxsName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SxsDirectory: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceSxsConfig,
                szSxsDirectory: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceSxsConfig,
                szSxsDirectory: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceSxsConfig_SxsConfig(self: *const T, scsConfig: CSC_SxsConfig) HRESULT {
                return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsConfig(@as(*const IServiceSxsConfig, @ptrCast(self)), scsConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceSxsConfig_SxsName(self: *const T, szSxsName: ?[*:0]const u16) HRESULT {
                return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsName(@as(*const IServiceSxsConfig, @ptrCast(self)), szSxsName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceSxsConfig_SxsDirectory(self: *const T, szSxsDirectory: ?[*:0]const u16) HRESULT {
                return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsDirectory(@as(*const IServiceSxsConfig, @ptrCast(self)), szSxsDirectory);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ICheckSxsConfig_Value = Guid.initString("0ff5a96f-11fc-47d1-baa6-25dd347e7242");
pub const IID_ICheckSxsConfig = &IID_ICheckSxsConfig_Value;
pub const ICheckSxsConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        IsSameSxsConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ICheckSxsConfig,
                wszSxsName: ?[*:0]const u16,
                wszSxsDirectory: ?[*:0]const u16,
                wszSxsAppName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ICheckSxsConfig,
                wszSxsName: ?[*:0]const u16,
                wszSxsDirectory: ?[*:0]const u16,
                wszSxsAppName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ICheckSxsConfig_IsSameSxsConfig(self: *const T, wszSxsName: ?[*:0]const u16, wszSxsDirectory: ?[*:0]const u16, wszSxsAppName: ?[*:0]const u16) HRESULT {
                return @as(*const ICheckSxsConfig.VTable, @ptrCast(self.vtable)).IsSameSxsConfig(@as(*const ICheckSxsConfig, @ptrCast(self)), wszSxsName, wszSxsDirectory, wszSxsAppName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceInheritanceConfig_Value = Guid.initString("92186771-d3b4-4d77-a8ea-ee842d586f35");
pub const IID_IServiceInheritanceConfig = &IID_IServiceInheritanceConfig_Value;
pub const IServiceInheritanceConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ContainingContextTreatment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceInheritanceConfig,
                inheritanceConfig: CSC_InheritanceConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceInheritanceConfig,
                inheritanceConfig: CSC_InheritanceConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceInheritanceConfig_ContainingContextTreatment(self: *const T, inheritanceConfig: CSC_InheritanceConfig) HRESULT {
                return @as(*const IServiceInheritanceConfig.VTable, @ptrCast(self.vtable)).ContainingContextTreatment(@as(*const IServiceInheritanceConfig, @ptrCast(self)), inheritanceConfig);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceThreadPoolConfig_Value = Guid.initString("186d89bc-f277-4bcc-80d5-4df7b836ef4a");
pub const IID_IServiceThreadPoolConfig = &IID_IServiceThreadPoolConfig_Value;
pub const IServiceThreadPoolConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SelectThreadPool: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceThreadPoolConfig,
                threadPool: CSC_ThreadPool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceThreadPoolConfig,
                threadPool: CSC_ThreadPool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBindingInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceThreadPoolConfig,
                binding: CSC_Binding,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceThreadPoolConfig,
                binding: CSC_Binding,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceThreadPoolConfig_SelectThreadPool(self: *const T, threadPool: CSC_ThreadPool) HRESULT {
                return @as(*const IServiceThreadPoolConfig.VTable, @ptrCast(self.vtable)).SelectThreadPool(@as(*const IServiceThreadPoolConfig, @ptrCast(self)), threadPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceThreadPoolConfig_SetBindingInfo(self: *const T, binding: CSC_Binding) HRESULT {
                return @as(*const IServiceThreadPoolConfig.VTable, @ptrCast(self.vtable)).SetBindingInfo(@as(*const IServiceThreadPoolConfig, @ptrCast(self)), binding);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceTransactionConfigBase_Value = Guid.initString("772b3fbe-6ffd-42fb-b5f8-8f9b260f3810");
pub const IID_IServiceTransactionConfigBase = &IID_IServiceTransactionConfigBase_Value;
pub const IServiceTransactionConfigBase = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ConfigureTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfigBase,
                transactionConfig: CSC_TransactionConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfigBase,
                transactionConfig: CSC_TransactionConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsolationLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfigBase,
                option: COMAdminTxIsolationLevelOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfigBase,
                option: COMAdminTxIsolationLevelOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TransactionTimeout: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfigBase,
                ulTimeoutSec: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfigBase,
                ulTimeoutSec: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BringYourOwnTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfigBase,
                szTipURL: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfigBase,
                szTipURL: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        NewTransactionDescription: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfigBase,
                szTxDesc: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfigBase,
                szTxDesc: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfigBase_ConfigureTransaction(self: *const T, transactionConfig: CSC_TransactionConfig) HRESULT {
                return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).ConfigureTransaction(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), transactionConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfigBase_IsolationLevel(self: *const T, option: COMAdminTxIsolationLevelOptions) HRESULT {
                return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).IsolationLevel(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), option);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfigBase_TransactionTimeout(self: *const T, ulTimeoutSec: u32) HRESULT {
                return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).TransactionTimeout(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), ulTimeoutSec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfigBase_BringYourOwnTransaction(self: *const T, szTipURL: ?[*:0]const u16) HRESULT {
                return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).BringYourOwnTransaction(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), szTipURL);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfigBase_NewTransactionDescription(self: *const T, szTxDesc: ?[*:0]const u16) HRESULT {
                return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).NewTransactionDescription(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), szTxDesc);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceTransactionConfig_Value = Guid.initString("59f4c2a3-d3d7-4a31-b6e4-6ab3177c50b9");
pub const IID_IServiceTransactionConfig = &IID_IServiceTransactionConfig_Value;
pub const IServiceTransactionConfig = extern struct {
    pub const VTable = extern struct {
        base: IServiceTransactionConfigBase.VTable,
        ConfigureBYOT: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTransactionConfig,
                pITxByot: ?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTransactionConfig,
                pITxByot: ?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IServiceTransactionConfigBase.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTransactionConfig_ConfigureBYOT(self: *const T, pITxByot: ?*ITransaction) HRESULT {
                return @as(*const IServiceTransactionConfig.VTable, @ptrCast(self.vtable)).ConfigureBYOT(@as(*const IServiceTransactionConfig, @ptrCast(self)), pITxByot);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceSysTxnConfig_Value = Guid.initString("33caf1a1-fcb8-472b-b45e-967448ded6d8");
pub const IID_IServiceSysTxnConfig = &IID_IServiceSysTxnConfig_Value;
pub const IServiceSysTxnConfig = extern struct {
    pub const VTable = extern struct {
        base: IServiceTransactionConfig.VTable,
        ConfigureBYOTSysTxn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceSysTxnConfig,
                pTxProxy: ?*ITransactionProxy,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceSysTxnConfig,
                pTxProxy: ?*ITransactionProxy,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IServiceTransactionConfig.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceSysTxnConfig_ConfigureBYOTSysTxn(self: *const T, pTxProxy: ?*ITransactionProxy) HRESULT {
                return @as(*const IServiceSysTxnConfig.VTable, @ptrCast(self.vtable)).ConfigureBYOTSysTxn(@as(*const IServiceSysTxnConfig, @ptrCast(self)), pTxProxy);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceSynchronizationConfig_Value = Guid.initString("fd880e81-6dce-4c58-af83-a208846c0030");
pub const IID_IServiceSynchronizationConfig = &IID_IServiceSynchronizationConfig_Value;
pub const IServiceSynchronizationConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ConfigureSynchronization: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceSynchronizationConfig,
                synchConfig: CSC_SynchronizationConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceSynchronizationConfig,
                synchConfig: CSC_SynchronizationConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceSynchronizationConfig_ConfigureSynchronization(self: *const T, synchConfig: CSC_SynchronizationConfig) HRESULT {
                return @as(*const IServiceSynchronizationConfig.VTable, @ptrCast(self.vtable)).ConfigureSynchronization(@as(*const IServiceSynchronizationConfig, @ptrCast(self)), synchConfig);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceTrackerConfig_Value = Guid.initString("6c3a3e1d-0ba6-4036-b76f-d0404db816c9");
pub const IID_IServiceTrackerConfig = &IID_IServiceTrackerConfig_Value;
pub const IServiceTrackerConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        TrackerConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceTrackerConfig,
                trackerConfig: CSC_TrackerConfig,
                szTrackerAppName: ?[*:0]const u16,
                szTrackerCtxName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceTrackerConfig,
                trackerConfig: CSC_TrackerConfig,
                szTrackerAppName: ?[*:0]const u16,
                szTrackerCtxName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceTrackerConfig_TrackerConfig(self: *const T, trackerConfig: CSC_TrackerConfig, szTrackerAppName: ?[*:0]const u16, szTrackerCtxName: ?[*:0]const u16) HRESULT {
                return @as(*const IServiceTrackerConfig.VTable, @ptrCast(self.vtable)).TrackerConfig(@as(*const IServiceTrackerConfig, @ptrCast(self)), trackerConfig, szTrackerAppName, szTrackerCtxName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServicePartitionConfig_Value = Guid.initString("80182d03-5ea4-4831-ae97-55beffc2e590");
pub const IID_IServicePartitionConfig = &IID_IServicePartitionConfig_Value;
pub const IServicePartitionConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PartitionConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServicePartitionConfig,
                partitionConfig: CSC_PartitionConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServicePartitionConfig,
                partitionConfig: CSC_PartitionConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PartitionID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServicePartitionConfig,
                guidPartitionID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServicePartitionConfig,
                guidPartitionID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePartitionConfig_PartitionConfig(self: *const T, partitionConfig: CSC_PartitionConfig) HRESULT {
                return @as(*const IServicePartitionConfig.VTable, @ptrCast(self.vtable)).PartitionConfig(@as(*const IServicePartitionConfig, @ptrCast(self)), partitionConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePartitionConfig_PartitionID(self: *const T, guidPartitionID: ?*const Guid) HRESULT {
                return @as(*const IServicePartitionConfig.VTable, @ptrCast(self.vtable)).PartitionID(@as(*const IServicePartitionConfig, @ptrCast(self)), guidPartitionID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceCall_Value = Guid.initString("bd3e2e12-42dd-40f4-a09a-95a50c58304b");
pub const IID_IServiceCall = &IID_IServiceCall_Value;
pub const IServiceCall = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceCall_OnCall(self: *const T) HRESULT {
                return @as(*const IServiceCall.VTable, @ptrCast(self.vtable)).OnCall(@as(*const IServiceCall, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IAsyncErrorNotify_Value = Guid.initString("fe6777fb-a674-4177-8f32-6d707e113484");
pub const IID_IAsyncErrorNotify = &IID_IAsyncErrorNotify_Value;
pub const IAsyncErrorNotify = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnError: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAsyncErrorNotify,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAsyncErrorNotify,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAsyncErrorNotify_OnError(self: *const T, hr: HRESULT) HRESULT {
                return @as(*const IAsyncErrorNotify.VTable, @ptrCast(self.vtable)).OnError(@as(*const IAsyncErrorNotify, @ptrCast(self)), hr);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServiceActivity_Value = Guid.initString("67532e0c-9e2f-4450-a354-035633944e17");
pub const IID_IServiceActivity = &IID_IServiceActivity_Value;
pub const IServiceActivity = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SynchronousCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceActivity,
                pIServiceCall: ?*IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceActivity,
                pIServiceCall: ?*IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AsynchronousCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceActivity,
                pIServiceCall: ?*IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceActivity,
                pIServiceCall: ?*IServiceCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BindToCurrentThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UnbindFromThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServiceActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServiceActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceActivity_SynchronousCall(self: *const T, pIServiceCall: ?*IServiceCall) HRESULT {
                return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).SynchronousCall(@as(*const IServiceActivity, @ptrCast(self)), pIServiceCall);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceActivity_AsynchronousCall(self: *const T, pIServiceCall: ?*IServiceCall) HRESULT {
                return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).AsynchronousCall(@as(*const IServiceActivity, @ptrCast(self)), pIServiceCall);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceActivity_BindToCurrentThread(self: *const T) HRESULT {
                return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).BindToCurrentThread(@as(*const IServiceActivity, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServiceActivity_UnbindFromThread(self: *const T) HRESULT {
                return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).UnbindFromThread(@as(*const IServiceActivity, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IThreadPoolKnobs_Value = Guid.initString("51372af7-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IThreadPoolKnobs = &IID_IThreadPoolKnobs_Value;
pub const IThreadPoolKnobs = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetMaxThreads: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                plcMaxThreads: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                plcMaxThreads: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrentThreads: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                plcCurrentThreads: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                plcCurrentThreads: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxThreads: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                lcMaxThreads: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                lcMaxThreads: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeleteDelay: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                pmsecDeleteDelay: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                pmsecDeleteDelay: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDeleteDelay: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                msecDeleteDelay: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                msecDeleteDelay: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMaxQueuedRequests: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                plcMaxQueuedRequests: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                plcMaxQueuedRequests: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrentQueuedRequests: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                plcCurrentQueuedRequests: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                plcCurrentQueuedRequests: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxQueuedRequests: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                lcMaxQueuedRequests: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                lcMaxQueuedRequests: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMinThreads: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                lcMinThreads: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                lcMinThreads: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetQueueDepth: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IThreadPoolKnobs,
                lcQueueDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IThreadPoolKnobs,
                lcQueueDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_GetMaxThreads(self: *const T, plcMaxThreads: ?*i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcMaxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_GetCurrentThreads(self: *const T, plcCurrentThreads: ?*i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetCurrentThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcCurrentThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_SetMaxThreads(self: *const T, lcMaxThreads: i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMaxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_GetDeleteDelay(self: *const T, pmsecDeleteDelay: ?*i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetDeleteDelay(@as(*const IThreadPoolKnobs, @ptrCast(self)), pmsecDeleteDelay);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_SetDeleteDelay(self: *const T, msecDeleteDelay: i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetDeleteDelay(@as(*const IThreadPoolKnobs, @ptrCast(self)), msecDeleteDelay);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_GetMaxQueuedRequests(self: *const T, plcMaxQueuedRequests: ?*i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcMaxQueuedRequests);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_GetCurrentQueuedRequests(self: *const T, plcCurrentQueuedRequests: ?*i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetCurrentQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcCurrentQueuedRequests);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_SetMaxQueuedRequests(self: *const T, lcMaxQueuedRequests: i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMaxQueuedRequests);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_SetMinThreads(self: *const T, lcMinThreads: i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMinThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMinThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IThreadPoolKnobs_SetQueueDepth(self: *const T, lcQueueDepth: i32) HRESULT {
                return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetQueueDepth(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcQueueDepth);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IComStaThreadPoolKnobs_Value = Guid.initString("324b64fa-33b6-11d2-98b7-00c04f8ee1c4");
pub const IID_IComStaThreadPoolKnobs = &IID_IComStaThreadPoolKnobs_Value;
pub const IComStaThreadPoolKnobs = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetMinThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                minThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                minThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMinThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                minThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                minThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                maxThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                maxThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMaxThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                maxThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                maxThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetActivityPerThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                activitiesPerThread: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                activitiesPerThread: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetActivityPerThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                activitiesPerThread: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                activitiesPerThread: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetActivityRatio: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                activityRatio: f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                activityRatio: f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetActivityRatio: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                activityRatio: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                activityRatio: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                pdwThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                pdwThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetQueueDepth: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                pdwQDepth: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                pdwQDepth: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetQueueDepth: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs,
                dwQDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs,
                dwQDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_SetMinThreadCount(self: *const T, minThreads: u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMinThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), minThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetMinThreadCount(self: *const T, minThreads: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMinThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), minThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_SetMaxThreadCount(self: *const T, maxThreads: u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), maxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetMaxThreadCount(self: *const T, maxThreads: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), maxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_SetActivityPerThread(self: *const T, activitiesPerThread: u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetActivityPerThread(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activitiesPerThread);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetActivityPerThread(self: *const T, activitiesPerThread: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetActivityPerThread(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activitiesPerThread);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_SetActivityRatio(self: *const T, activityRatio: f64) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetActivityRatio(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activityRatio);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetActivityRatio(self: *const T, activityRatio: ?*f64) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetActivityRatio(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activityRatio);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetThreadCount(self: *const T, pdwThreads: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), pdwThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_GetQueueDepth(self: *const T, pdwQDepth: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetQueueDepth(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), pdwQDepth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs_SetQueueDepth(self: *const T, dwQDepth: i32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetQueueDepth(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), dwQDepth);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IComMtaThreadPoolKnobs_Value = Guid.initString("f9a76d2e-76a5-43eb-a0c4-49bec8e48480");
pub const IID_IComMtaThreadPoolKnobs = &IID_IComMtaThreadPoolKnobs_Value;
pub const IComMtaThreadPoolKnobs = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        MTASetMaxThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMtaThreadPoolKnobs,
                dwMaxThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMtaThreadPoolKnobs,
                dwMaxThreads: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MTAGetMaxThreadCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMtaThreadPoolKnobs,
                pdwMaxThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMtaThreadPoolKnobs,
                pdwMaxThreads: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MTASetThrottleValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMtaThreadPoolKnobs,
                dwThrottle: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMtaThreadPoolKnobs,
                dwThrottle: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MTAGetThrottleValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComMtaThreadPoolKnobs,
                pdwThrottle: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComMtaThreadPoolKnobs,
                pdwThrottle: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMtaThreadPoolKnobs_MTASetMaxThreadCount(self: *const T, dwMaxThreads: u32) HRESULT {
                return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTASetMaxThreadCount(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), dwMaxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMtaThreadPoolKnobs_MTAGetMaxThreadCount(self: *const T, pdwMaxThreads: ?*u32) HRESULT {
                return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTAGetMaxThreadCount(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), pdwMaxThreads);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMtaThreadPoolKnobs_MTASetThrottleValue(self: *const T, dwThrottle: u32) HRESULT {
                return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTASetThrottleValue(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), dwThrottle);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComMtaThreadPoolKnobs_MTAGetThrottleValue(self: *const T, pdwThrottle: ?*u32) HRESULT {
                return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTAGetThrottleValue(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), pdwThrottle);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IComStaThreadPoolKnobs2_Value = Guid.initString("73707523-ff9a-4974-bf84-2108dc213740");
pub const IID_IComStaThreadPoolKnobs2 = &IID_IComStaThreadPoolKnobs2_Value;
pub const IComStaThreadPoolKnobs2 = extern struct {
    pub const VTable = extern struct {
        base: IComStaThreadPoolKnobs.VTable,
        GetMaxCPULoad: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwLoad: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwLoad: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxCPULoad: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwLoad: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwLoad: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCPUMetricEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pbMetricEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pbMetricEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetCPUMetricEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                bMetricEnabled: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                bMetricEnabled: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCreateThreadsAggressively: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pbMetricEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pbMetricEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetCreateThreadsAggressively: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                bMetricEnabled: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                bMetricEnabled: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMaxCSR: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwCSR: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwCSR: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxCSR: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                dwCSR: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                dwCSR: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetWaitTimeForThreadCleanup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwThreadCleanupWaitTime: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                pdwThreadCleanupWaitTime: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetWaitTimeForThreadCleanup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IComStaThreadPoolKnobs2,
                dwThreadCleanupWaitTime: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IComStaThreadPoolKnobs2,
                dwThreadCleanupWaitTime: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IComStaThreadPoolKnobs.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_GetMaxCPULoad(self: *const T, pdwLoad: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetMaxCPULoad(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwLoad);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_SetMaxCPULoad(self: *const T, pdwLoad: i32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetMaxCPULoad(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwLoad);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_GetCPUMetricEnabled(self: *const T, pbMetricEnabled: ?*BOOL) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetCPUMetricEnabled(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pbMetricEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_SetCPUMetricEnabled(self: *const T, bMetricEnabled: BOOL) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetCPUMetricEnabled(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), bMetricEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_GetCreateThreadsAggressively(self: *const T, pbMetricEnabled: ?*BOOL) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetCreateThreadsAggressively(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pbMetricEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_SetCreateThreadsAggressively(self: *const T, bMetricEnabled: BOOL) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetCreateThreadsAggressively(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), bMetricEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_GetMaxCSR(self: *const T, pdwCSR: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetMaxCSR(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwCSR);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_SetMaxCSR(self: *const T, dwCSR: i32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetMaxCSR(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), dwCSR);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_GetWaitTimeForThreadCleanup(self: *const T, pdwThreadCleanupWaitTime: ?*u32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetWaitTimeForThreadCleanup(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwThreadCleanupWaitTime);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IComStaThreadPoolKnobs2_SetWaitTimeForThreadCleanup(self: *const T, dwThreadCleanupWaitTime: i32) HRESULT {
                return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetWaitTimeForThreadCleanup(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), dwThreadCleanupWaitTime);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IProcessInitializer_Value = Guid.initString("1113f52d-dc7f-4943-aed6-88d04027e32a");
pub const IID_IProcessInitializer = &IID_IProcessInitializer_Value;
pub const IProcessInitializer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Startup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IProcessInitializer,
                punkProcessControl: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IProcessInitializer,
                punkProcessControl: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Shutdown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IProcessInitializer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IProcessInitializer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IProcessInitializer_Startup(self: *const T, punkProcessControl: ?*IUnknown) HRESULT {
                return @as(*const IProcessInitializer.VTable, @ptrCast(self.vtable)).Startup(@as(*const IProcessInitializer, @ptrCast(self)), punkProcessControl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IProcessInitializer_Shutdown(self: *const T) HRESULT {
                return @as(*const IProcessInitializer.VTable, @ptrCast(self.vtable)).Shutdown(@as(*const IProcessInitializer, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IServicePoolConfig_Value = Guid.initString("a9690656-5bca-470c-8451-250c1f43a33e");
pub const IID_IServicePoolConfig = &IID_IServicePoolConfig_Value;
pub const IServicePoolConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_MaxPoolSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                dwMaxPool: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                dwMaxPool: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_MaxPoolSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pdwMaxPool: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pdwMaxPool: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_MinPoolSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                dwMinPool: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                dwMinPool: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_MinPoolSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pdwMinPool: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pdwMinPool: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_CreationTimeout: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                dwCreationTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                dwCreationTimeout: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CreationTimeout: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pdwCreationTimeout: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pdwCreationTimeout: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_TransactionAffinity: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                fTxAffinity: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                fTxAffinity: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TransactionAffinity: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pfTxAffinity: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pfTxAffinity: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ClassFactory: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pFactory: ?*IClassFactory,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pFactory: ?*IClassFactory,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ClassFactory: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IServicePoolConfig,
                pFactory: ?*?*IClassFactory,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IServicePoolConfig,
                pFactory: ?*?*IClassFactory,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_put_MaxPoolSize(self: *const T, dwMaxPool: u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_MaxPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), dwMaxPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_get_MaxPoolSize(self: *const T, pdwMaxPool: ?*u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_MaxPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), pdwMaxPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_put_MinPoolSize(self: *const T, dwMinPool: u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_MinPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), dwMinPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_get_MinPoolSize(self: *const T, pdwMinPool: ?*u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_MinPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), pdwMinPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_put_CreationTimeout(self: *const T, dwCreationTimeout: u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_CreationTimeout(@as(*const IServicePoolConfig, @ptrCast(self)), dwCreationTimeout);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_get_CreationTimeout(self: *const T, pdwCreationTimeout: ?*u32) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_CreationTimeout(@as(*const IServicePoolConfig, @ptrCast(self)), pdwCreationTimeout);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_put_TransactionAffinity(self: *const T, fTxAffinity: BOOL) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_TransactionAffinity(@as(*const IServicePoolConfig, @ptrCast(self)), fTxAffinity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_get_TransactionAffinity(self: *const T, pfTxAffinity: ?*BOOL) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_TransactionAffinity(@as(*const IServicePoolConfig, @ptrCast(self)), pfTxAffinity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_put_ClassFactory(self: *const T, pFactory: ?*IClassFactory) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_ClassFactory(@as(*const IServicePoolConfig, @ptrCast(self)), pFactory);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePoolConfig_get_ClassFactory(self: *const T, pFactory: ?*?*IClassFactory) HRESULT {
                return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_ClassFactory(@as(*const IServicePoolConfig, @ptrCast(self)), pFactory);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IServicePool_Value = Guid.initString("b302df81-ea45-451e-99a2-09f9fd1b1e13");
pub const IID_IServicePool = &IID_IServicePool_Value;
pub const IServicePool = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServicePool,
                pPoolConfig: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServicePool,
                pPoolConfig: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServicePool,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServicePool,
                riid: ?*const Guid,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Shutdown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IServicePool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IServicePool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePool_Initialize(self: *const T, pPoolConfig: ?*IUnknown) HRESULT {
                return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IServicePool, @ptrCast(self)), pPoolConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePool_GetObject(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) HRESULT {
                return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).GetObject(@as(*const IServicePool, @ptrCast(self)), riid, ppv);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IServicePool_Shutdown(self: *const T) HRESULT {
                return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).Shutdown(@as(*const IServicePool, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IManagedPooledObj_Value = Guid.initString("c5da4bea-1b42-4437-8926-b6a38860a770");
pub const IID_IManagedPooledObj = &IID_IManagedPooledObj_Value;
pub const IManagedPooledObj = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetHeld: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedPooledObj,
                m_bHeld: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedPooledObj,
                m_bHeld: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedPooledObj_SetHeld(self: *const T, m_bHeld: BOOL) HRESULT {
                return @as(*const IManagedPooledObj.VTable, @ptrCast(self.vtable)).SetHeld(@as(*const IManagedPooledObj, @ptrCast(self)), m_bHeld);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IManagedPoolAction_Value = Guid.initString("da91b74e-5388-4783-949d-c1cd5fb00506");
pub const IID_IManagedPoolAction = &IID_IManagedPoolAction_Value;
pub const IManagedPoolAction = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        LastRelease: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedPoolAction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedPoolAction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedPoolAction_LastRelease(self: *const T) HRESULT {
                return @as(*const IManagedPoolAction.VTable, @ptrCast(self.vtable)).LastRelease(@as(*const IManagedPoolAction, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IManagedObjectInfo_Value = Guid.initString("1427c51a-4584-49d8-90a0-c50d8086cbe9");
pub const IID_IManagedObjectInfo = &IID_IManagedObjectInfo_Value;
pub const IManagedObjectInfo = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetIUnknown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedObjectInfo,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedObjectInfo,
                pUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIObjectControl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedObjectInfo,
                pCtrl: ?*?*IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedObjectInfo,
                pCtrl: ?*?*IObjectControl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetInPool: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedObjectInfo,
                bInPool: BOOL,
                pPooledObj: ?*IManagedPooledObj,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedObjectInfo,
                bInPool: BOOL,
                pPooledObj: ?*IManagedPooledObj,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetWrapperStrength: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedObjectInfo,
                bStrong: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedObjectInfo,
                bStrong: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedObjectInfo_GetIUnknown(self: *const T, pUnk: ?*?*IUnknown) HRESULT {
                return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).GetIUnknown(@as(*const IManagedObjectInfo, @ptrCast(self)), pUnk);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedObjectInfo_GetIObjectControl(self: *const T, pCtrl: ?*?*IObjectControl) HRESULT {
                return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).GetIObjectControl(@as(*const IManagedObjectInfo, @ptrCast(self)), pCtrl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedObjectInfo_SetInPool(self: *const T, bInPool: BOOL, pPooledObj: ?*IManagedPooledObj) HRESULT {
                return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).SetInPool(@as(*const IManagedObjectInfo, @ptrCast(self)), bInPool, pPooledObj);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedObjectInfo_SetWrapperStrength(self: *const T, bStrong: BOOL) HRESULT {
                return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).SetWrapperStrength(@as(*const IManagedObjectInfo, @ptrCast(self)), bStrong);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IAppDomainHelper_Value = Guid.initString("c7b67079-8255-42c6-9ec0-6994a3548780");
pub const IID_IAppDomainHelper = &IID_IAppDomainHelper_Value;
pub const IAppDomainHelper = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAppDomainHelper,
                pUnkAD: ?*IUnknown,
                __MIDL__IAppDomainHelper0000: isize,
                pPool: ?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAppDomainHelper,
                pUnkAD: ?*IUnknown,
                __MIDL__IAppDomainHelper0000: isize,
                pPool: ?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DoCallback: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAppDomainHelper,
                pUnkAD: ?*IUnknown,
                __MIDL__IAppDomainHelper0001: isize,
                pPool: ?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAppDomainHelper,
                pUnkAD: ?*IUnknown,
                __MIDL__IAppDomainHelper0001: isize,
                pPool: ?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAppDomainHelper_Initialize(self: *const T, pUnkAD: ?*IUnknown, __MIDL__IAppDomainHelper0000: isize, pPool: ?*anyopaque) HRESULT {
                return @as(*const IAppDomainHelper.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IAppDomainHelper, @ptrCast(self)), pUnkAD, __MIDL__IAppDomainHelper0000, pPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAppDomainHelper_DoCallback(self: *const T, pUnkAD: ?*IUnknown, __MIDL__IAppDomainHelper0001: isize, pPool: ?*anyopaque) HRESULT {
                return @as(*const IAppDomainHelper.VTable, @ptrCast(self.vtable)).DoCallback(@as(*const IAppDomainHelper, @ptrCast(self)), pUnkAD, __MIDL__IAppDomainHelper0001, pPool);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IAssemblyLocator_Value = Guid.initString("391ffbb9-a8ee-432a-abc8-baa238dab90f");
pub const IID_IAssemblyLocator = &IID_IAssemblyLocator_Value;
pub const IAssemblyLocator = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetModules: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAssemblyLocator,
                applicationDir: ?BSTR,
                applicationName: ?BSTR,
                assemblyName: ?BSTR,
                pModules: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAssemblyLocator,
                applicationDir: ?BSTR,
                applicationName: ?BSTR,
                assemblyName: ?BSTR,
                pModules: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAssemblyLocator_GetModules(self: *const T, applicationDir: ?BSTR, applicationName: ?BSTR, assemblyName: ?BSTR, pModules: ?*?*SAFEARRAY) HRESULT {
                return @as(*const IAssemblyLocator.VTable, @ptrCast(self.vtable)).GetModules(@as(*const IAssemblyLocator, @ptrCast(self)), applicationDir, applicationName, assemblyName, pModules);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IManagedActivationEvents_Value = Guid.initString("a5f325af-572f-46da-b8ab-827c3d95d99e");
pub const IID_IManagedActivationEvents = &IID_IManagedActivationEvents_Value;
pub const IManagedActivationEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateManagedStub: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedActivationEvents,
                pInfo: ?*IManagedObjectInfo,
                fDist: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedActivationEvents,
                pInfo: ?*IManagedObjectInfo,
                fDist: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DestroyManagedStub: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IManagedActivationEvents,
                pInfo: ?*IManagedObjectInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IManagedActivationEvents,
                pInfo: ?*IManagedObjectInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedActivationEvents_CreateManagedStub(self: *const T, pInfo: ?*IManagedObjectInfo, fDist: BOOL) HRESULT {
                return @as(*const IManagedActivationEvents.VTable, @ptrCast(self.vtable)).CreateManagedStub(@as(*const IManagedActivationEvents, @ptrCast(self)), pInfo, fDist);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IManagedActivationEvents_DestroyManagedStub(self: *const T, pInfo: ?*IManagedObjectInfo) HRESULT {
                return @as(*const IManagedActivationEvents.VTable, @ptrCast(self.vtable)).DestroyManagedStub(@as(*const IManagedActivationEvents, @ptrCast(self)), pInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_ISendMethodEvents_Value = Guid.initString("2732fd59-b2b4-4d44-878c-8b8f09626008");
pub const IID_ISendMethodEvents = &IID_ISendMethodEvents_Value;
pub const ISendMethodEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SendMethodCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISendMethodEvents,
                pIdentity: ?*const anyopaque,
                riid: ?*const Guid,
                dwMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISendMethodEvents,
                pIdentity: ?*const anyopaque,
                riid: ?*const Guid,
                dwMeth: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendMethodReturn: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISendMethodEvents,
                pIdentity: ?*const anyopaque,
                riid: ?*const Guid,
                dwMeth: u32,
                hrCall: HRESULT,
                hrServer: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISendMethodEvents,
                pIdentity: ?*const anyopaque,
                riid: ?*const Guid,
                dwMeth: u32,
                hrCall: HRESULT,
                hrServer: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISendMethodEvents_SendMethodCall(self: *const T, pIdentity: ?*const anyopaque, riid: ?*const Guid, dwMeth: u32) HRESULT {
                return @as(*const ISendMethodEvents.VTable, @ptrCast(self.vtable)).SendMethodCall(@as(*const ISendMethodEvents, @ptrCast(self)), pIdentity, riid, dwMeth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISendMethodEvents_SendMethodReturn(self: *const T, pIdentity: ?*const anyopaque, riid: ?*const Guid, dwMeth: u32, hrCall: HRESULT, hrServer: HRESULT) HRESULT {
                return @as(*const ISendMethodEvents.VTable, @ptrCast(self.vtable)).SendMethodReturn(@as(*const ISendMethodEvents, @ptrCast(self)), pIdentity, riid, dwMeth, hrCall, hrServer);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ITransactionResourcePool_Value = Guid.initString("c5feb7c1-346a-11d1-b1cc-00aa00ba3258");
pub const IID_ITransactionResourcePool = &IID_ITransactionResourcePool_Value;
pub const ITransactionResourcePool = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PutResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourcePool,
                pPool: ?*IObjPool,
                pUnk: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourcePool,
                pPool: ?*IObjPool,
                pUnk: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourcePool,
                pPool: ?*IObjPool,
                ppUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourcePool,
                pPool: ?*IObjPool,
                ppUnk: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResourcePool_PutResource(self: *const T, pPool: ?*IObjPool, pUnk: ?*IUnknown) HRESULT {
                return @as(*const ITransactionResourcePool.VTable, @ptrCast(self.vtable)).PutResource(@as(*const ITransactionResourcePool, @ptrCast(self)), pPool, pUnk);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResourcePool_GetResource(self: *const T, pPool: ?*IObjPool, ppUnk: ?*?*IUnknown) HRESULT {
                return @as(*const ITransactionResourcePool.VTable, @ptrCast(self.vtable)).GetResource(@as(*const ITransactionResourcePool, @ptrCast(self)), pPool, ppUnk);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMTSCall_Value = Guid.initString("51372aef-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IMTSCall = &IID_IMTSCall_Value;
pub const IMTSCall = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSCall_OnCall(self: *const T) HRESULT {
                return @as(*const IMTSCall.VTable, @ptrCast(self.vtable)).OnCall(@as(*const IMTSCall, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IContextProperties_Value = Guid.initString("d396da85-bf8f-11d1-bbae-00c04fc2fa5f");
pub const IID_IContextProperties = &IID_IContextProperties_Value;
pub const IContextProperties = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Count: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextProperties,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextProperties,
                plCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextProperties,
                name: ?BSTR,
                pProperty: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextProperties,
                name: ?BSTR,
                pProperty: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnumNames: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextProperties,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextProperties,
                ppenum: ?*?*IEnumNames,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextProperties,
                name: ?BSTR,
                property: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextProperties,
                name: ?BSTR,
                property: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContextProperties,
                name: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContextProperties,
                name: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextProperties_Count(self: *const T, plCount: ?*i32) HRESULT {
                return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).Count(@as(*const IContextProperties, @ptrCast(self)), plCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextProperties_GetProperty(self: *const T, name: ?BSTR, pProperty: ?*VARIANT) HRESULT {
                return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IContextProperties, @ptrCast(self)), name, pProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextProperties_EnumNames(self: *const T, ppenum: ?*?*IEnumNames) HRESULT {
                return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).EnumNames(@as(*const IContextProperties, @ptrCast(self)), ppenum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextProperties_SetProperty(self: *const T, name: ?BSTR, property: VARIANT) HRESULT {
                return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IContextProperties, @ptrCast(self)), name, property);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContextProperties_RemoveProperty(self: *const T, name: ?BSTR) HRESULT {
                return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).RemoveProperty(@as(*const IContextProperties, @ptrCast(self)), name);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IObjPool_Value = Guid.initString("7d8805a0-2ea7-11d1-b1cc-00aa00ba3258");
pub const IID_IObjPool = &IID_IObjPool_Value;
pub const IObjPool = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Reserved1: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved3: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved4: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        PutEndTx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
                pObj: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
                pObj: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved5: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved6: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IObjPool,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved1(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const IObjPool, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved2(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const IObjPool, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved3(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved3(@as(*const IObjPool, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved4(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved4(@as(*const IObjPool, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_PutEndTx(self: *const T, pObj: ?*IUnknown) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).PutEndTx(@as(*const IObjPool, @ptrCast(self)), pObj);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved5(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved5(@as(*const IObjPool, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IObjPool_Reserved6(self: *const T) void {
                return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved6(@as(*const IObjPool, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_ITransactionProperty_Value = Guid.initString("788ea814-87b1-11d1-bba6-00c04fc2fa5f");
pub const IID_ITransactionProperty = &IID_ITransactionProperty_Value;
pub const ITransactionProperty = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Reserved1: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved3: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved4: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved5: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved6: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved7: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved8: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved9: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        GetTransactionResourcePool: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
                ppTxPool: ?*?*ITransactionResourcePool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionProperty,
                ppTxPool: ?*?*ITransactionResourcePool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reserved10: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved11: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved12: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved13: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved14: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved15: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved16: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        Reserved17: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const ITransactionProperty,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved1(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved2(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved3(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved3(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved4(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved4(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved5(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved5(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved6(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved6(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved7(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved7(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved8(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved8(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved9(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved9(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_GetTransactionResourcePool(self: *const T, ppTxPool: ?*?*ITransactionResourcePool) HRESULT {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).GetTransactionResourcePool(@as(*const ITransactionProperty, @ptrCast(self)), ppTxPool);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved10(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved10(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved11(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved11(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved12(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved12(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved13(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved13(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved14(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved14(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved15(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved15(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved16(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved16(@as(*const ITransactionProperty, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionProperty_Reserved17(self: *const T) void {
                return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved17(@as(*const ITransactionProperty, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IMTSActivity_Value = Guid.initString("51372af0-cae7-11cf-be81-00aa00a2fa25");
pub const IID_IMTSActivity = &IID_IMTSActivity_Value;
pub const IMTSActivity = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SynchronousCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSActivity,
                pCall: ?*IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSActivity,
                pCall: ?*IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AsyncCall: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSActivity,
                pCall: ?*IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSActivity,
                pCall: ?*IMTSCall,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reserved1: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        BindToCurrentThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UnbindFromThread: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMTSActivity,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSActivity_SynchronousCall(self: *const T, pCall: ?*IMTSCall) HRESULT {
                return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).SynchronousCall(@as(*const IMTSActivity, @ptrCast(self)), pCall);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSActivity_AsyncCall(self: *const T, pCall: ?*IMTSCall) HRESULT {
                return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).AsyncCall(@as(*const IMTSActivity, @ptrCast(self)), pCall);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSActivity_Reserved1(self: *const T) void {
                return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const IMTSActivity, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSActivity_BindToCurrentThread(self: *const T) HRESULT {
                return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).BindToCurrentThread(@as(*const IMTSActivity, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMTSActivity_UnbindFromThread(self: *const T) HRESULT {
                return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).UnbindFromThread(@as(*const IMTSActivity, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const AutoSvcs_Error_Constants = enum(u32) {
    mtsErrCtxAborted = 2147803138,
    mtsErrCtxAborting = 2147803139,
    mtsErrCtxNoContext = 2147803140,
    mtsErrCtxNotRegistered = 2147803141,
    mtsErrCtxSynchTimeout = 2147803142,
    mtsErrCtxOldReference = 2147803143,
    mtsErrCtxRoleNotFound = 2147803148,
    mtsErrCtxNoSecurity = 2147803149,
    mtsErrCtxWrongThread = 2147803150,
    mtsErrCtxTMNotAvailable = 2147803151,
    comQCErrApplicationNotQueued = 2148599296,
    comQCErrNoQueueableInterfaces = 2148599297,
    comQCErrQueuingServiceNotAvailable = 2148599298,
    comQCErrQueueTransactMismatch = 2148599299,
    comqcErrRecorderMarshalled = 2148599300,
    comqcErrOutParam = 2148599301,
    comqcErrRecorderNotTrusted = 2148599302,
    comqcErrPSLoad = 2148599303,
    comqcErrMarshaledObjSameTxn = 2148599304,
    comqcErrInvalidMessage = 2148599376,
    comqcErrMsmqSidUnavailable = 2148599377,
    comqcErrWrongMsgExtension = 2148599378,
    comqcErrMsmqServiceUnavailable = 2148599379,
    comqcErrMsgNotAuthenticated = 2148599380,
    comqcErrMsmqConnectorUsed = 2148599381,
    comqcErrBadMarshaledObject = 2148599382,
};
pub const mtsErrCtxAborted = AutoSvcs_Error_Constants.mtsErrCtxAborted;
pub const mtsErrCtxAborting = AutoSvcs_Error_Constants.mtsErrCtxAborting;
pub const mtsErrCtxNoContext = AutoSvcs_Error_Constants.mtsErrCtxNoContext;
pub const mtsErrCtxNotRegistered = AutoSvcs_Error_Constants.mtsErrCtxNotRegistered;
pub const mtsErrCtxSynchTimeout = AutoSvcs_Error_Constants.mtsErrCtxSynchTimeout;
pub const mtsErrCtxOldReference = AutoSvcs_Error_Constants.mtsErrCtxOldReference;
pub const mtsErrCtxRoleNotFound = AutoSvcs_Error_Constants.mtsErrCtxRoleNotFound;
pub const mtsErrCtxNoSecurity = AutoSvcs_Error_Constants.mtsErrCtxNoSecurity;
pub const mtsErrCtxWrongThread = AutoSvcs_Error_Constants.mtsErrCtxWrongThread;
pub const mtsErrCtxTMNotAvailable = AutoSvcs_Error_Constants.mtsErrCtxTMNotAvailable;
pub const comQCErrApplicationNotQueued = AutoSvcs_Error_Constants.comQCErrApplicationNotQueued;
pub const comQCErrNoQueueableInterfaces = AutoSvcs_Error_Constants.comQCErrNoQueueableInterfaces;
pub const comQCErrQueuingServiceNotAvailable = AutoSvcs_Error_Constants.comQCErrQueuingServiceNotAvailable;
pub const comQCErrQueueTransactMismatch = AutoSvcs_Error_Constants.comQCErrQueueTransactMismatch;
pub const comqcErrRecorderMarshalled = AutoSvcs_Error_Constants.comqcErrRecorderMarshalled;
pub const comqcErrOutParam = AutoSvcs_Error_Constants.comqcErrOutParam;
pub const comqcErrRecorderNotTrusted = AutoSvcs_Error_Constants.comqcErrRecorderNotTrusted;
pub const comqcErrPSLoad = AutoSvcs_Error_Constants.comqcErrPSLoad;
pub const comqcErrMarshaledObjSameTxn = AutoSvcs_Error_Constants.comqcErrMarshaledObjSameTxn;
pub const comqcErrInvalidMessage = AutoSvcs_Error_Constants.comqcErrInvalidMessage;
pub const comqcErrMsmqSidUnavailable = AutoSvcs_Error_Constants.comqcErrMsmqSidUnavailable;
pub const comqcErrWrongMsgExtension = AutoSvcs_Error_Constants.comqcErrWrongMsgExtension;
pub const comqcErrMsmqServiceUnavailable = AutoSvcs_Error_Constants.comqcErrMsmqServiceUnavailable;
pub const comqcErrMsgNotAuthenticated = AutoSvcs_Error_Constants.comqcErrMsgNotAuthenticated;
pub const comqcErrMsmqConnectorUsed = AutoSvcs_Error_Constants.comqcErrMsmqConnectorUsed;
pub const comqcErrBadMarshaledObject = AutoSvcs_Error_Constants.comqcErrBadMarshaledObject;

pub const LockModes = enum(i32) {
    SetGet = 0,
    Method = 1,
};
pub const LockSetGet = LockModes.SetGet;
pub const LockMethod = LockModes.Method;

pub const ReleaseModes = enum(i32) {
    Standard = 0,
    Process = 1,
};
pub const Standard = ReleaseModes.Standard;
pub const Process = ReleaseModes.Process;

pub const CRMFLAGS = enum(i32) {
    FORGETTARGET = 1,
    WRITTENDURINGPREPARE = 2,
    WRITTENDURINGCOMMIT = 4,
    WRITTENDURINGABORT = 8,
    WRITTENDURINGRECOVERY = 16,
    WRITTENDURINGREPLAY = 32,
    REPLAYINPROGRESS = 64,
};
pub const CRMFLAG_FORGETTARGET = CRMFLAGS.FORGETTARGET;
pub const CRMFLAG_WRITTENDURINGPREPARE = CRMFLAGS.WRITTENDURINGPREPARE;
pub const CRMFLAG_WRITTENDURINGCOMMIT = CRMFLAGS.WRITTENDURINGCOMMIT;
pub const CRMFLAG_WRITTENDURINGABORT = CRMFLAGS.WRITTENDURINGABORT;
pub const CRMFLAG_WRITTENDURINGRECOVERY = CRMFLAGS.WRITTENDURINGRECOVERY;
pub const CRMFLAG_WRITTENDURINGREPLAY = CRMFLAGS.WRITTENDURINGREPLAY;
pub const CRMFLAG_REPLAYINPROGRESS = CRMFLAGS.REPLAYINPROGRESS;

pub const CRMREGFLAGS = enum(i32) {
    PREPAREPHASE = 1,
    COMMITPHASE = 2,
    ABORTPHASE = 4,
    ALLPHASES = 7,
    FAILIFINDOUBTSREMAIN = 16,
};
pub const CRMREGFLAG_PREPAREPHASE = CRMREGFLAGS.PREPAREPHASE;
pub const CRMREGFLAG_COMMITPHASE = CRMREGFLAGS.COMMITPHASE;
pub const CRMREGFLAG_ABORTPHASE = CRMREGFLAGS.ABORTPHASE;
pub const CRMREGFLAG_ALLPHASES = CRMREGFLAGS.ALLPHASES;
pub const CRMREGFLAG_FAILIFINDOUBTSREMAIN = CRMREGFLAGS.FAILIFINDOUBTSREMAIN;

//--------------------------------------------------------------------------------
// Section: Functions (9)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ole32" fn CoGetDefaultContext(
    aptType: APTTYPE,
    riid: ?*const Guid,
    ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "comsvcs" fn CoCreateActivity(
    pIUnknown: ?*IUnknown,
    riid: ?*const Guid,
    ppObj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "comsvcs" fn CoEnterServiceDomain(
    pConfigObject: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "comsvcs" fn CoLeaveServiceDomain(
    pUnkStatus: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) void;

// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "comsvcs" fn GetManagedExtensions(
    dwExts: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.0'
pub extern "comsvcs" fn SafeRef(
    rid: ?*const Guid,
    pUnk: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

// TODO: this type is limited to platform 'windows5.0'
pub extern "comsvcs" fn RecycleSurrogate(
    lReasonCode: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.0'
pub extern "comsvcs" fn MTSCreateActivity(
    riid: ?*const Guid,
    ppobj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows5.0'
pub extern "mtxdm" fn GetDispenserManager(
    param0: ?*?*IDispenserManager,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (17)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const APTTYPE = @import("../system/com.zig").APTTYPE;
const BLOB = @import("../system/com.zig").BLOB;
const BOOL = @import("../foundation.zig").BOOL;
const BSTR = @import("../foundation.zig").BSTR;
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const IClassFactory = @import("../system/com.zig").IClassFactory;
const IDispatch = @import("../system/com.zig").IDispatch;
const ITransaction = @import("../system/distributed_transaction_coordinator.zig").ITransaction;
const ITransactionVoterBallotAsync2 = @import("../system/distributed_transaction_coordinator.zig").ITransactionVoterBallotAsync2;
const ITransactionVoterNotifyAsync2 = @import("../system/distributed_transaction_coordinator.zig").ITransactionVoterNotifyAsync2;
const IUnknown = @import("../system/com.zig").IUnknown;
const PSID = @import("../foundation.zig").PSID;
const PWSTR = @import("../foundation.zig").PWSTR;
const SAFEARRAY = @import("../system/com.zig").SAFEARRAY;
const VARIANT = @import("../system/com.zig").VARIANT;

test {
    @setEvalBranchQuota(comptime @import("std").meta.declarations(@This()).len * 3);

    // reference all the pub declarations
    if (!@import("builtin").is_test) return;
    inline for (comptime @import("std").meta.declarations(@This())) |decl| {
        if (decl.is_pub) {
            _ = @field(@This(), decl.name);
        }
    }
}
