//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (69)
//--------------------------------------------------------------------------------
pub const DTCINSTALL_E_CLIENT_ALREADY_INSTALLED = @as(i32, 384);
pub const DTCINSTALL_E_SERVER_ALREADY_INSTALLED = @as(i32, 385);
pub const XA_SWITCH_F_DTC = @as(u32, 1);
pub const XA_FMTID_DTC = @as(u32, 4478019);
pub const XA_FMTID_DTC_VER1 = @as(u32, 21255235);
pub const XIDDATASIZE = @as(u32, 128);
pub const MAXGTRIDSIZE = @as(u32, 64);
pub const MAXBQUALSIZE = @as(u32, 64);
pub const RMNAMESZ = @as(u32, 32);
pub const MAXINFOSIZE = @as(u32, 256);
pub const TMNOFLAGS = @as(i32, 0);
pub const TMREGISTER = @as(i32, 1);
pub const TMNOMIGRATE = @as(i32, 2);
pub const TMUSEASYNC = @as(i32, 4);
pub const TMASYNC = @as(i32, -2147483648);
pub const TMONEPHASE = @as(i32, 1073741824);
pub const TMFAIL = @as(i32, 536870912);
pub const TMNOWAIT = @as(i32, 268435456);
pub const TMRESUME = @as(i32, 134217728);
pub const TMSUCCESS = @as(i32, 67108864);
pub const TMSUSPEND = @as(i32, 33554432);
pub const TMSTARTRSCAN = @as(i32, 16777216);
pub const TMENDRSCAN = @as(i32, 8388608);
pub const TMMULTIPLE = @as(i32, 4194304);
pub const TMJOIN = @as(i32, 2097152);
pub const TMMIGRATE = @as(i32, 1048576);
pub const TM_JOIN = @as(u32, 2);
pub const TM_RESUME = @as(u32, 1);
pub const TM_OK = @as(u32, 0);
pub const TMER_TMERR = @as(i32, -1);
pub const TMER_INVAL = @as(i32, -2);
pub const TMER_PROTO = @as(i32, -3);
pub const XA_RBBASE = @as(u32, 100);
pub const XA_RBROLLBACK = @as(u32, 100);
pub const XA_RBCOMMFAIL = @as(u32, 101);
pub const XA_RBDEADLOCK = @as(u32, 102);
pub const XA_RBINTEGRITY = @as(u32, 103);
pub const XA_RBOTHER = @as(u32, 104);
pub const XA_RBPROTO = @as(u32, 105);
pub const XA_RBTIMEOUT = @as(u32, 106);
pub const XA_RBTRANSIENT = @as(u32, 107);
pub const XA_RBEND = @as(u32, 107);
pub const XA_NOMIGRATE = @as(u32, 9);
pub const XA_HEURHAZ = @as(u32, 8);
pub const XA_HEURCOM = @as(u32, 7);
pub const XA_HEURRB = @as(u32, 6);
pub const XA_HEURMIX = @as(u32, 5);
pub const XA_RETRY = @as(u32, 4);
pub const XA_RDONLY = @as(u32, 3);
pub const XA_OK = @as(u32, 0);
pub const XAER_ASYNC = @as(i32, -2);
pub const XAER_RMERR = @as(i32, -3);
pub const XAER_NOTA = @as(i32, -4);
pub const XAER_INVAL = @as(i32, -5);
pub const XAER_PROTO = @as(i32, -6);
pub const XAER_RMFAIL = @as(i32, -7);
pub const XAER_DUPID = @as(i32, -8);
pub const XAER_OUTSIDE = @as(i32, -9);
pub const DTC_INSTALL_OVERWRITE_CLIENT = @as(u32, 1);
pub const DTC_INSTALL_OVERWRITE_SERVER = @as(u32, 2);
pub const OLE_TM_CONFIG_VERSION_1 = @as(u32, 1);
pub const OLE_TM_CONFIG_VERSION_2 = @as(u32, 2);
pub const OLE_TM_FLAG_NONE = @as(u32, 0);
pub const OLE_TM_FLAG_NODEMANDSTART = @as(u32, 1);
pub const OLE_TM_FLAG_NOAGILERECOVERY = @as(u32, 2);
pub const OLE_TM_FLAG_QUERY_SERVICE_LOCKSTATUS = @as(u32, 2147483648);
pub const OLE_TM_FLAG_INTERNAL_TO_TM = @as(u32, 1073741824);
pub const CLSID_MSDtcTransactionManager = Guid.initString("5b18ab61-091d-11d1-97df-00c04fb9618a");
pub const CLSID_MSDtcTransaction = Guid.initString("39f8d76b-0928-11d1-97df-00c04fb9618a");

//--------------------------------------------------------------------------------
// Section: Types (110)
//--------------------------------------------------------------------------------
pub const DTC_STATUS_ = enum(i32) {
    UNKNOWN = 0,
    STARTING = 1,
    STARTED = 2,
    PAUSING = 3,
    PAUSED = 4,
    CONTINUING = 5,
    STOPPING = 6,
    STOPPED = 7,
    E_CANTCONTROL = 8,
    FAILED = 9,
};
pub const DTC_STATUS_UNKNOWN = DTC_STATUS_.UNKNOWN;
pub const DTC_STATUS_STARTING = DTC_STATUS_.STARTING;
pub const DTC_STATUS_STARTED = DTC_STATUS_.STARTED;
pub const DTC_STATUS_PAUSING = DTC_STATUS_.PAUSING;
pub const DTC_STATUS_PAUSED = DTC_STATUS_.PAUSED;
pub const DTC_STATUS_CONTINUING = DTC_STATUS_.CONTINUING;
pub const DTC_STATUS_STOPPING = DTC_STATUS_.STOPPING;
pub const DTC_STATUS_STOPPED = DTC_STATUS_.STOPPED;
pub const DTC_STATUS_E_CANTCONTROL = DTC_STATUS_.E_CANTCONTROL;
pub const DTC_STATUS_FAILED = DTC_STATUS_.FAILED;

pub const DTC_GET_TRANSACTION_MANAGER = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        pszHost: ?PSTR,
        pszTmName: ?PSTR,
        rid: ?*const Guid,
        dwReserved1: u32,
        wcbReserved2: u16,
        pvReserved2: ?*anyopaque,
        ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
    else => *const fn (
        pszHost: ?PSTR,
        pszTmName: ?PSTR,
        rid: ?*const Guid,
        dwReserved1: u32,
        wcbReserved2: u16,
        pvReserved2: ?*anyopaque,
        ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
};

pub const DTC_GET_TRANSACTION_MANAGER_EX_A = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        i_pszHost: ?PSTR,
        i_pszTmName: ?PSTR,
        i_riid: ?*const Guid,
        i_grfOptions: u32,
        i_pvConfigParams: ?*anyopaque,
        o_ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
    else => *const fn (
        i_pszHost: ?PSTR,
        i_pszTmName: ?PSTR,
        i_riid: ?*const Guid,
        i_grfOptions: u32,
        i_pvConfigParams: ?*anyopaque,
        o_ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
};

pub const DTC_GET_TRANSACTION_MANAGER_EX_W = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        i_pwszHost: ?PWSTR,
        i_pwszTmName: ?PWSTR,
        i_riid: ?*const Guid,
        i_grfOptions: u32,
        i_pvConfigParams: ?*anyopaque,
        o_ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
    else => *const fn (
        i_pwszHost: ?PWSTR,
        i_pwszTmName: ?PWSTR,
        i_riid: ?*const Guid,
        i_grfOptions: u32,
        i_pvConfigParams: ?*anyopaque,
        o_ppvObject: ?*?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
};

pub const DTC_INSTALL_CLIENT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        i_pszRemoteTmHostName: ?*i8,
        i_dwProtocol: u32,
        i_dwOverwrite: u32,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
    else => *const fn (
        i_pszRemoteTmHostName: ?*i8,
        i_dwProtocol: u32,
        i_dwOverwrite: u32,
    ) callconv(@import("std").os.windows.WINAPI) HRESULT,
};

pub const BOID = extern struct {
    rgb: [16]u8,
};

pub const TX_MISC_CONSTANTS = enum(i32) {
    C = 40,
};
pub const MAX_TRAN_DESC = TX_MISC_CONSTANTS.C;

pub const ISOLATIONLEVEL = enum(i32) {
    UNSPECIFIED = -1,
    CHAOS = 16,
    READUNCOMMITTED = 256,
    // BROWSE = 256, this enum value conflicts with READUNCOMMITTED
    CURSORSTABILITY = 4096,
    // READCOMMITTED = 4096, this enum value conflicts with CURSORSTABILITY
    REPEATABLEREAD = 65536,
    SERIALIZABLE = 1048576,
    // ISOLATED = 1048576, this enum value conflicts with SERIALIZABLE
};
pub const ISOLATIONLEVEL_UNSPECIFIED = ISOLATIONLEVEL.UNSPECIFIED;
pub const ISOLATIONLEVEL_CHAOS = ISOLATIONLEVEL.CHAOS;
pub const ISOLATIONLEVEL_READUNCOMMITTED = ISOLATIONLEVEL.READUNCOMMITTED;
pub const ISOLATIONLEVEL_BROWSE = ISOLATIONLEVEL.READUNCOMMITTED;
pub const ISOLATIONLEVEL_CURSORSTABILITY = ISOLATIONLEVEL.CURSORSTABILITY;
pub const ISOLATIONLEVEL_READCOMMITTED = ISOLATIONLEVEL.CURSORSTABILITY;
pub const ISOLATIONLEVEL_REPEATABLEREAD = ISOLATIONLEVEL.REPEATABLEREAD;
pub const ISOLATIONLEVEL_SERIALIZABLE = ISOLATIONLEVEL.SERIALIZABLE;
pub const ISOLATIONLEVEL_ISOLATED = ISOLATIONLEVEL.SERIALIZABLE;

pub const XACTTRANSINFO = extern struct {
    uow: BOID,
    isoLevel: i32,
    isoFlags: u32,
    grfTCSupported: u32,
    grfRMSupported: u32,
    grfTCSupportedRetaining: u32,
    grfRMSupportedRetaining: u32,
};

pub const XACTSTATS = extern struct {
    cOpen: u32,
    cCommitting: u32,
    cCommitted: u32,
    cAborting: u32,
    cAborted: u32,
    cInDoubt: u32,
    cHeuristicDecision: u32,
    timeTransactionsUp: FILETIME,
};

pub const ISOFLAG = enum(i32) {
    RETAIN_COMMIT_DC = 1,
    RETAIN_COMMIT = 2,
    RETAIN_COMMIT_NO = 3,
    RETAIN_ABORT_DC = 4,
    RETAIN_ABORT = 8,
    RETAIN_ABORT_NO = 12,
    RETAIN_DONTCARE = 5,
    RETAIN_BOTH = 10,
    RETAIN_NONE = 15,
    OPTIMISTIC = 16,
    READONLY = 32,
};
pub const ISOFLAG_RETAIN_COMMIT_DC = ISOFLAG.RETAIN_COMMIT_DC;
pub const ISOFLAG_RETAIN_COMMIT = ISOFLAG.RETAIN_COMMIT;
pub const ISOFLAG_RETAIN_COMMIT_NO = ISOFLAG.RETAIN_COMMIT_NO;
pub const ISOFLAG_RETAIN_ABORT_DC = ISOFLAG.RETAIN_ABORT_DC;
pub const ISOFLAG_RETAIN_ABORT = ISOFLAG.RETAIN_ABORT;
pub const ISOFLAG_RETAIN_ABORT_NO = ISOFLAG.RETAIN_ABORT_NO;
pub const ISOFLAG_RETAIN_DONTCARE = ISOFLAG.RETAIN_DONTCARE;
pub const ISOFLAG_RETAIN_BOTH = ISOFLAG.RETAIN_BOTH;
pub const ISOFLAG_RETAIN_NONE = ISOFLAG.RETAIN_NONE;
pub const ISOFLAG_OPTIMISTIC = ISOFLAG.OPTIMISTIC;
pub const ISOFLAG_READONLY = ISOFLAG.READONLY;

pub const XACTTC = enum(i32) {
    NONE = 0,
    SYNC_PHASEONE = 1,
    SYNC_PHASETWO = 2,
    // SYNC = 2, this enum value conflicts with SYNC_PHASETWO
    ASYNC_PHASEONE = 4,
    // ASYNC = 4, this enum value conflicts with ASYNC_PHASEONE
};
pub const XACTTC_NONE = XACTTC.NONE;
pub const XACTTC_SYNC_PHASEONE = XACTTC.SYNC_PHASEONE;
pub const XACTTC_SYNC_PHASETWO = XACTTC.SYNC_PHASETWO;
pub const XACTTC_SYNC = XACTTC.SYNC_PHASETWO;
pub const XACTTC_ASYNC_PHASEONE = XACTTC.ASYNC_PHASEONE;
pub const XACTTC_ASYNC = XACTTC.ASYNC_PHASEONE;

pub const XACTRM = enum(i32) {
    OPTIMISTICLASTWINS = 1,
    NOREADONLYPREPARES = 2,
};
pub const XACTRM_OPTIMISTICLASTWINS = XACTRM.OPTIMISTICLASTWINS;
pub const XACTRM_NOREADONLYPREPARES = XACTRM.NOREADONLYPREPARES;

pub const XACTCONST = enum(i32) {
    E = 0,
};
pub const XACTCONST_TIMEOUTINFINITE = XACTCONST.E;

pub const XACTHEURISTIC = enum(i32) {
    ABORT = 1,
    COMMIT = 2,
    DAMAGE = 3,
    DANGER = 4,
};
pub const XACTHEURISTIC_ABORT = XACTHEURISTIC.ABORT;
pub const XACTHEURISTIC_COMMIT = XACTHEURISTIC.COMMIT;
pub const XACTHEURISTIC_DAMAGE = XACTHEURISTIC.DAMAGE;
pub const XACTHEURISTIC_DANGER = XACTHEURISTIC.DANGER;

pub const XACTSTAT = enum(i32) {
    NONE = 0,
    OPENNORMAL = 1,
    OPENREFUSED = 2,
    PREPARING = 4,
    PREPARED = 8,
    PREPARERETAINING = 16,
    PREPARERETAINED = 32,
    COMMITTING = 64,
    COMMITRETAINING = 128,
    ABORTING = 256,
    ABORTED = 512,
    COMMITTED = 1024,
    HEURISTIC_ABORT = 2048,
    HEURISTIC_COMMIT = 4096,
    HEURISTIC_DAMAGE = 8192,
    HEURISTIC_DANGER = 16384,
    FORCED_ABORT = 32768,
    FORCED_COMMIT = 65536,
    INDOUBT = 131072,
    CLOSED = 262144,
    OPEN = 3,
    NOTPREPARED = 524227,
    ALL = 524287,
};
pub const XACTSTAT_NONE = XACTSTAT.NONE;
pub const XACTSTAT_OPENNORMAL = XACTSTAT.OPENNORMAL;
pub const XACTSTAT_OPENREFUSED = XACTSTAT.OPENREFUSED;
pub const XACTSTAT_PREPARING = XACTSTAT.PREPARING;
pub const XACTSTAT_PREPARED = XACTSTAT.PREPARED;
pub const XACTSTAT_PREPARERETAINING = XACTSTAT.PREPARERETAINING;
pub const XACTSTAT_PREPARERETAINED = XACTSTAT.PREPARERETAINED;
pub const XACTSTAT_COMMITTING = XACTSTAT.COMMITTING;
pub const XACTSTAT_COMMITRETAINING = XACTSTAT.COMMITRETAINING;
pub const XACTSTAT_ABORTING = XACTSTAT.ABORTING;
pub const XACTSTAT_ABORTED = XACTSTAT.ABORTED;
pub const XACTSTAT_COMMITTED = XACTSTAT.COMMITTED;
pub const XACTSTAT_HEURISTIC_ABORT = XACTSTAT.HEURISTIC_ABORT;
pub const XACTSTAT_HEURISTIC_COMMIT = XACTSTAT.HEURISTIC_COMMIT;
pub const XACTSTAT_HEURISTIC_DAMAGE = XACTSTAT.HEURISTIC_DAMAGE;
pub const XACTSTAT_HEURISTIC_DANGER = XACTSTAT.HEURISTIC_DANGER;
pub const XACTSTAT_FORCED_ABORT = XACTSTAT.FORCED_ABORT;
pub const XACTSTAT_FORCED_COMMIT = XACTSTAT.FORCED_COMMIT;
pub const XACTSTAT_INDOUBT = XACTSTAT.INDOUBT;
pub const XACTSTAT_CLOSED = XACTSTAT.CLOSED;
pub const XACTSTAT_OPEN = XACTSTAT.OPEN;
pub const XACTSTAT_NOTPREPARED = XACTSTAT.NOTPREPARED;
pub const XACTSTAT_ALL = XACTSTAT.ALL;

pub const XACTOPT = extern struct {
    ulTimeout: u32,
    szDescription: [40]u8,
};

const IID_ITransaction_Value = Guid.initString("0fb15084-af41-11ce-bd2b-204c4f4f5020");
pub const IID_ITransaction = &IID_ITransaction_Value;
pub const ITransaction = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Commit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransaction,
                fRetaining: BOOL,
                grfTC: u32,
                grfRM: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransaction,
                fRetaining: BOOL,
                grfTC: u32,
                grfRM: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Abort: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransaction,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                fAsync: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransaction,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                fAsync: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransaction,
                pinfo: ?*XACTTRANSINFO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransaction,
                pinfo: ?*XACTTRANSINFO,
            ) 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 ITransaction_Commit(self: *const T, fRetaining: BOOL, grfTC: u32, grfRM: u32) HRESULT {
                return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransaction, @ptrCast(self)), fRetaining, grfTC, grfRM);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransaction_Abort(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, fAsync: BOOL) HRESULT {
                return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransaction, @ptrCast(self)), pboidReason, fRetaining, fAsync);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransaction_GetTransactionInfo(self: *const T, pinfo: ?*XACTTRANSINFO) HRESULT {
                return @as(*const ITransaction.VTable, @ptrCast(self.vtable)).GetTransactionInfo(@as(*const ITransaction, @ptrCast(self)), pinfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionCloner_Value = Guid.initString("02656950-2152-11d0-944c-00a0c905416e");
pub const IID_ITransactionCloner = &IID_ITransactionCloner_Value;
pub const ITransactionCloner = extern struct {
    pub const VTable = extern struct {
        base: ITransaction.VTable,
        CloneWithCommitDisabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionCloner,
                ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionCloner,
                ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace ITransaction.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionCloner_CloneWithCommitDisabled(self: *const T, ppITransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITransactionCloner.VTable, @ptrCast(self.vtable)).CloneWithCommitDisabled(@as(*const ITransactionCloner, @ptrCast(self)), ppITransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransaction2_Value = Guid.initString("34021548-0065-11d3-bac1-00c04f797be2");
pub const IID_ITransaction2 = &IID_ITransaction2_Value;
pub const ITransaction2 = extern struct {
    pub const VTable = extern struct {
        base: ITransactionCloner.VTable,
        GetTransactionInfo2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransaction2,
                pinfo: ?*XACTTRANSINFO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransaction2,
                pinfo: ?*XACTTRANSINFO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace ITransactionCloner.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransaction2_GetTransactionInfo2(self: *const T, pinfo: ?*XACTTRANSINFO) HRESULT {
                return @as(*const ITransaction2.VTable, @ptrCast(self.vtable)).GetTransactionInfo2(@as(*const ITransaction2, @ptrCast(self)), pinfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionDispenser_Value = Guid.initString("3a6ad9e1-23b9-11cf-ad60-00aa00a74ccd");
pub const IID_ITransactionDispenser = &IID_ITransactionDispenser_Value;
pub const ITransactionDispenser = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetOptionsObject: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionDispenser,
                ppOptions: ?*?*ITransactionOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionDispenser,
                ppOptions: ?*?*ITransactionOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionDispenser,
                punkOuter: ?*IUnknown,
                isoLevel: i32,
                isoFlags: u32,
                pOptions: ?*ITransactionOptions,
                ppTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionDispenser,
                punkOuter: ?*IUnknown,
                isoLevel: i32,
                isoFlags: u32,
                pOptions: ?*ITransactionOptions,
                ppTransaction: ?*?*ITransaction,
            ) 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 ITransactionDispenser_GetOptionsObject(self: *const T, ppOptions: ?*?*ITransactionOptions) HRESULT {
                return @as(*const ITransactionDispenser.VTable, @ptrCast(self.vtable)).GetOptionsObject(@as(*const ITransactionDispenser, @ptrCast(self)), ppOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionDispenser_BeginTransaction(self: *const T, punkOuter: ?*IUnknown, isoLevel: i32, isoFlags: u32, pOptions: ?*ITransactionOptions, ppTransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITransactionDispenser.VTable, @ptrCast(self.vtable)).BeginTransaction(@as(*const ITransactionDispenser, @ptrCast(self)), punkOuter, isoLevel, isoFlags, pOptions, ppTransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionOptions_Value = Guid.initString("3a6ad9e0-23b9-11cf-ad60-00aa00a74ccd");
pub const IID_ITransactionOptions = &IID_ITransactionOptions_Value;
pub const ITransactionOptions = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOptions,
                pOptions: ?*XACTOPT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOptions,
                pOptions: ?*XACTOPT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOptions,
                pOptions: ?*XACTOPT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOptions,
                pOptions: ?*XACTOPT,
            ) 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 ITransactionOptions_SetOptions(self: *const T, pOptions: ?*XACTOPT) HRESULT {
                return @as(*const ITransactionOptions.VTable, @ptrCast(self.vtable)).SetOptions(@as(*const ITransactionOptions, @ptrCast(self)), pOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionOptions_GetOptions(self: *const T, pOptions: ?*XACTOPT) HRESULT {
                return @as(*const ITransactionOptions.VTable, @ptrCast(self.vtable)).GetOptions(@as(*const ITransactionOptions, @ptrCast(self)), pOptions);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionOutcomeEvents_Value = Guid.initString("3a6ad9e2-23b9-11cf-ad60-00aa00a74ccd");
pub const IID_ITransactionOutcomeEvents = &IID_ITransactionOutcomeEvents_Value;
pub const ITransactionOutcomeEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Committed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOutcomeEvents,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOutcomeEvents,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Aborted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOutcomeEvents,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOutcomeEvents,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HeuristicDecision: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOutcomeEvents,
                dwDecision: u32,
                pboidReason: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOutcomeEvents,
                dwDecision: u32,
                pboidReason: ?*BOID,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Indoubt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionOutcomeEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionOutcomeEvents,
            ) 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 ITransactionOutcomeEvents_Committed(self: *const T, fRetaining: BOOL, pNewUOW: ?*BOID, hr: HRESULT) HRESULT {
                return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Committed(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), fRetaining, pNewUOW, hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionOutcomeEvents_Aborted(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID, hr: HRESULT) HRESULT {
                return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Aborted(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), pboidReason, fRetaining, pNewUOW, hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionOutcomeEvents_HeuristicDecision(self: *const T, dwDecision: u32, pboidReason: ?*BOID, hr: HRESULT) HRESULT {
                return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).HeuristicDecision(@as(*const ITransactionOutcomeEvents, @ptrCast(self)), dwDecision, pboidReason, hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionOutcomeEvents_Indoubt(self: *const T) HRESULT {
                return @as(*const ITransactionOutcomeEvents.VTable, @ptrCast(self.vtable)).Indoubt(@as(*const ITransactionOutcomeEvents, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITmNodeName_Value = Guid.initString("30274f88-6ee4-474e-9b95-7807bc9ef8cf");
pub const IID_ITmNodeName = &IID_ITmNodeName_Value;
pub const ITmNodeName = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetNodeNameSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITmNodeName,
                pcbNodeNameSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITmNodeName,
                pcbNodeNameSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNodeName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITmNodeName,
                cbNodeNameBufferSize: u32,
                pNodeNameBuffer: ?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITmNodeName,
                cbNodeNameBufferSize: u32,
                pNodeNameBuffer: ?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 ITmNodeName_GetNodeNameSize(self: *const T, pcbNodeNameSize: ?*u32) HRESULT {
                return @as(*const ITmNodeName.VTable, @ptrCast(self.vtable)).GetNodeNameSize(@as(*const ITmNodeName, @ptrCast(self)), pcbNodeNameSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITmNodeName_GetNodeName(self: *const T, cbNodeNameBufferSize: u32, pNodeNameBuffer: ?PWSTR) HRESULT {
                return @as(*const ITmNodeName.VTable, @ptrCast(self.vtable)).GetNodeName(@as(*const ITmNodeName, @ptrCast(self)), cbNodeNameBufferSize, pNodeNameBuffer);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IKernelTransaction_Value = Guid.initString("79427a2b-f895-40e0-be79-b57dc82ed231");
pub const IID_IKernelTransaction = &IID_IKernelTransaction_Value;
pub const IKernelTransaction = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetHandle: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IKernelTransaction,
                pHandle: ?*?HANDLE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IKernelTransaction,
                pHandle: ?*?HANDLE,
            ) 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 IKernelTransaction_GetHandle(self: *const T, pHandle: ?*?HANDLE) HRESULT {
                return @as(*const IKernelTransaction.VTable, @ptrCast(self.vtable)).GetHandle(@as(*const IKernelTransaction, @ptrCast(self)), pHandle);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionResourceAsync_Value = Guid.initString("69e971f0-23ce-11cf-ad60-00aa00a74ccd");
pub const IID_ITransactionResourceAsync = &IID_ITransactionResourceAsync_Value;
pub const ITransactionResourceAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PrepareRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourceAsync,
                fRetaining: BOOL,
                grfRM: u32,
                fWantMoniker: BOOL,
                fSinglePhase: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourceAsync,
                fRetaining: BOOL,
                grfRM: u32,
                fWantMoniker: BOOL,
                fSinglePhase: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourceAsync,
                grfRM: u32,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourceAsync,
                grfRM: u32,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourceAsync,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourceAsync,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TMDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResourceAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResourceAsync,
            ) 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 ITransactionResourceAsync_PrepareRequest(self: *const T, fRetaining: BOOL, grfRM: u32, fWantMoniker: BOOL, fSinglePhase: BOOL) HRESULT {
                return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).PrepareRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), fRetaining, grfRM, fWantMoniker, fSinglePhase);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResourceAsync_CommitRequest(self: *const T, grfRM: u32, pNewUOW: ?*BOID) HRESULT {
                return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).CommitRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), grfRM, pNewUOW);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResourceAsync_AbortRequest(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID) HRESULT {
                return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).AbortRequest(@as(*const ITransactionResourceAsync, @ptrCast(self)), pboidReason, fRetaining, pNewUOW);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResourceAsync_TMDown(self: *const T) HRESULT {
                return @as(*const ITransactionResourceAsync.VTable, @ptrCast(self.vtable)).TMDown(@as(*const ITransactionResourceAsync, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionLastResourceAsync_Value = Guid.initString("c82bd532-5b30-11d3-8a91-00c04f79eb6d");
pub const IID_ITransactionLastResourceAsync = &IID_ITransactionLastResourceAsync_Value;
pub const ITransactionLastResourceAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        DelegateCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionLastResourceAsync,
                grfRM: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionLastResourceAsync,
                grfRM: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ForgetRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionLastResourceAsync,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionLastResourceAsync,
                pNewUOW: ?*BOID,
            ) 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 ITransactionLastResourceAsync_DelegateCommit(self: *const T, grfRM: u32) HRESULT {
                return @as(*const ITransactionLastResourceAsync.VTable, @ptrCast(self.vtable)).DelegateCommit(@as(*const ITransactionLastResourceAsync, @ptrCast(self)), grfRM);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionLastResourceAsync_ForgetRequest(self: *const T, pNewUOW: ?*BOID) HRESULT {
                return @as(*const ITransactionLastResourceAsync.VTable, @ptrCast(self.vtable)).ForgetRequest(@as(*const ITransactionLastResourceAsync, @ptrCast(self)), pNewUOW);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionResource_Value = Guid.initString("ee5ff7b3-4572-11d0-9452-00a0c905416e");
pub const IID_ITransactionResource = &IID_ITransactionResource_Value;
pub const ITransactionResource = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PrepareRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResource,
                fRetaining: BOOL,
                grfRM: u32,
                fWantMoniker: BOOL,
                fSinglePhase: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResource,
                fRetaining: BOOL,
                grfRM: u32,
                fWantMoniker: BOOL,
                fSinglePhase: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResource,
                grfRM: u32,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResource,
                grfRM: u32,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResource,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResource,
                pboidReason: ?*BOID,
                fRetaining: BOOL,
                pNewUOW: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TMDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionResource,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionResource,
            ) 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 ITransactionResource_PrepareRequest(self: *const T, fRetaining: BOOL, grfRM: u32, fWantMoniker: BOOL, fSinglePhase: BOOL) HRESULT {
                return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).PrepareRequest(@as(*const ITransactionResource, @ptrCast(self)), fRetaining, grfRM, fWantMoniker, fSinglePhase);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResource_CommitRequest(self: *const T, grfRM: u32, pNewUOW: ?*BOID) HRESULT {
                return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).CommitRequest(@as(*const ITransactionResource, @ptrCast(self)), grfRM, pNewUOW);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResource_AbortRequest(self: *const T, pboidReason: ?*BOID, fRetaining: BOOL, pNewUOW: ?*BOID) HRESULT {
                return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).AbortRequest(@as(*const ITransactionResource, @ptrCast(self)), pboidReason, fRetaining, pNewUOW);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionResource_TMDown(self: *const T) HRESULT {
                return @as(*const ITransactionResource.VTable, @ptrCast(self.vtable)).TMDown(@as(*const ITransactionResource, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionEnlistmentAsync_Value = Guid.initString("0fb15081-af41-11ce-bd2b-204c4f4f5020");
pub const IID_ITransactionEnlistmentAsync = &IID_ITransactionEnlistmentAsync_Value;
pub const ITransactionEnlistmentAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PrepareRequestDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionEnlistmentAsync,
                hr: HRESULT,
                pmk: ?*IMoniker,
                pboidReason: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionEnlistmentAsync,
                hr: HRESULT,
                pmk: ?*IMoniker,
                pboidReason: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitRequestDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionEnlistmentAsync,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionEnlistmentAsync,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortRequestDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionEnlistmentAsync,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionEnlistmentAsync,
                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 ITransactionEnlistmentAsync_PrepareRequestDone(self: *const T, hr: HRESULT, pmk: ?*IMoniker, pboidReason: ?*BOID) HRESULT {
                return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).PrepareRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr, pmk, pboidReason);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionEnlistmentAsync_CommitRequestDone(self: *const T, hr: HRESULT) HRESULT {
                return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).CommitRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionEnlistmentAsync_AbortRequestDone(self: *const T, hr: HRESULT) HRESULT {
                return @as(*const ITransactionEnlistmentAsync.VTable, @ptrCast(self.vtable)).AbortRequestDone(@as(*const ITransactionEnlistmentAsync, @ptrCast(self)), hr);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionLastEnlistmentAsync_Value = Guid.initString("c82bd533-5b30-11d3-8a91-00c04f79eb6d");
pub const IID_ITransactionLastEnlistmentAsync = &IID_ITransactionLastEnlistmentAsync_Value;
pub const ITransactionLastEnlistmentAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        TransactionOutcome: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionLastEnlistmentAsync,
                XactStat: XACTSTAT,
                pboidReason: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionLastEnlistmentAsync,
                XactStat: XACTSTAT,
                pboidReason: ?*BOID,
            ) 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 ITransactionLastEnlistmentAsync_TransactionOutcome(self: *const T, XactStat: XACTSTAT, pboidReason: ?*BOID) HRESULT {
                return @as(*const ITransactionLastEnlistmentAsync.VTable, @ptrCast(self.vtable)).TransactionOutcome(@as(*const ITransactionLastEnlistmentAsync, @ptrCast(self)), XactStat, pboidReason);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionExportFactory_Value = Guid.initString("e1cf9b53-8745-11ce-a9ba-00aa006c3706");
pub const IID_ITransactionExportFactory = &IID_ITransactionExportFactory_Value;
pub const ITransactionExportFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetRemoteClassId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionExportFactory,
                pclsid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionExportFactory,
                pclsid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionExportFactory,
                cbWhereabouts: u32,
                rgbWhereabouts: [*:0]u8,
                ppExport: ?*?*ITransactionExport,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionExportFactory,
                cbWhereabouts: u32,
                rgbWhereabouts: [*:0]u8,
                ppExport: ?*?*ITransactionExport,
            ) 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 ITransactionExportFactory_GetRemoteClassId(self: *const T, pclsid: ?*Guid) HRESULT {
                return @as(*const ITransactionExportFactory.VTable, @ptrCast(self.vtable)).GetRemoteClassId(@as(*const ITransactionExportFactory, @ptrCast(self)), pclsid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionExportFactory_Create(self: *const T, cbWhereabouts: u32, rgbWhereabouts: [*:0]u8, ppExport: ?*?*ITransactionExport) HRESULT {
                return @as(*const ITransactionExportFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionExportFactory, @ptrCast(self)), cbWhereabouts, rgbWhereabouts, ppExport);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionImportWhereabouts_Value = Guid.initString("0141fda4-8fc0-11ce-bd18-204c4f4f5020");
pub const IID_ITransactionImportWhereabouts = &IID_ITransactionImportWhereabouts_Value;
pub const ITransactionImportWhereabouts = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetWhereaboutsSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionImportWhereabouts,
                pcbWhereabouts: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionImportWhereabouts,
                pcbWhereabouts: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetWhereabouts: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionImportWhereabouts,
                cbWhereabouts: u32,
                rgbWhereabouts: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionImportWhereabouts,
                cbWhereabouts: u32,
                rgbWhereabouts: [*:0]u8,
                pcbUsed: ?*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 ITransactionImportWhereabouts_GetWhereaboutsSize(self: *const T, pcbWhereabouts: ?*u32) HRESULT {
                return @as(*const ITransactionImportWhereabouts.VTable, @ptrCast(self.vtable)).GetWhereaboutsSize(@as(*const ITransactionImportWhereabouts, @ptrCast(self)), pcbWhereabouts);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionImportWhereabouts_GetWhereabouts(self: *const T, cbWhereabouts: u32, rgbWhereabouts: [*:0]u8, pcbUsed: ?*u32) HRESULT {
                return @as(*const ITransactionImportWhereabouts.VTable, @ptrCast(self.vtable)).GetWhereabouts(@as(*const ITransactionImportWhereabouts, @ptrCast(self)), cbWhereabouts, rgbWhereabouts, pcbUsed);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionExport_Value = Guid.initString("0141fda5-8fc0-11ce-bd18-204c4f4f5020");
pub const IID_ITransactionExport = &IID_ITransactionExport_Value;
pub const ITransactionExport = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Export: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionExport,
                punkTransaction: ?*IUnknown,
                pcbTransactionCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionExport,
                punkTransaction: ?*IUnknown,
                pcbTransactionCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionCookie: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionExport,
                punkTransaction: ?*IUnknown,
                cbTransactionCookie: u32,
                rgbTransactionCookie: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionExport,
                punkTransaction: ?*IUnknown,
                cbTransactionCookie: u32,
                rgbTransactionCookie: [*:0]u8,
                pcbUsed: ?*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 ITransactionExport_Export(self: *const T, punkTransaction: ?*IUnknown, pcbTransactionCookie: ?*u32) HRESULT {
                return @as(*const ITransactionExport.VTable, @ptrCast(self.vtable)).Export(@as(*const ITransactionExport, @ptrCast(self)), punkTransaction, pcbTransactionCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionExport_GetTransactionCookie(self: *const T, punkTransaction: ?*IUnknown, cbTransactionCookie: u32, rgbTransactionCookie: [*:0]u8, pcbUsed: ?*u32) HRESULT {
                return @as(*const ITransactionExport.VTable, @ptrCast(self.vtable)).GetTransactionCookie(@as(*const ITransactionExport, @ptrCast(self)), punkTransaction, cbTransactionCookie, rgbTransactionCookie, pcbUsed);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionImport_Value = Guid.initString("e1cf9b5a-8745-11ce-a9ba-00aa006c3706");
pub const IID_ITransactionImport = &IID_ITransactionImport_Value;
pub const ITransactionImport = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Import: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionImport,
                cbTransactionCookie: u32,
                rgbTransactionCookie: [*:0]u8,
                piid: ?*const Guid,
                ppvTransaction: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionImport,
                cbTransactionCookie: u32,
                rgbTransactionCookie: [*:0]u8,
                piid: ?*const Guid,
                ppvTransaction: ?*?*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 ITransactionImport_Import(self: *const T, cbTransactionCookie: u32, rgbTransactionCookie: [*:0]u8, piid: ?*const Guid, ppvTransaction: ?*?*anyopaque) HRESULT {
                return @as(*const ITransactionImport.VTable, @ptrCast(self.vtable)).Import(@as(*const ITransactionImport, @ptrCast(self)), cbTransactionCookie, rgbTransactionCookie, piid, ppvTransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITipTransaction_Value = Guid.initString("17cf72d0-bac5-11d1-b1bf-00c04fc2f3ef");
pub const IID_ITipTransaction = &IID_ITipTransaction_Value;
pub const ITipTransaction = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Push: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipTransaction,
                i_pszRemoteTmUrl: ?*u8,
                o_ppszRemoteTxUrl: ?*?PSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipTransaction,
                i_pszRemoteTmUrl: ?*u8,
                o_ppszRemoteTxUrl: ?*?PSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransactionUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipTransaction,
                o_ppszLocalTxUrl: ?*?PSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipTransaction,
                o_ppszLocalTxUrl: ?*?PSTR,
            ) 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 ITipTransaction_Push(self: *const T, i_pszRemoteTmUrl: ?*u8, o_ppszRemoteTxUrl: ?*?PSTR) HRESULT {
                return @as(*const ITipTransaction.VTable, @ptrCast(self.vtable)).Push(@as(*const ITipTransaction, @ptrCast(self)), i_pszRemoteTmUrl, o_ppszRemoteTxUrl);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITipTransaction_GetTransactionUrl(self: *const T, o_ppszLocalTxUrl: ?*?PSTR) HRESULT {
                return @as(*const ITipTransaction.VTable, @ptrCast(self.vtable)).GetTransactionUrl(@as(*const ITipTransaction, @ptrCast(self)), o_ppszLocalTxUrl);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITipHelper_Value = Guid.initString("17cf72d1-bac5-11d1-b1bf-00c04fc2f3ef");
pub const IID_ITipHelper = &IID_ITipHelper_Value;
pub const ITipHelper = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Pull: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipHelper,
                i_pszTxUrl: ?*u8,
                o_ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipHelper,
                i_pszTxUrl: ?*u8,
                o_ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PullAsync: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipHelper,
                i_pszTxUrl: ?*u8,
                i_pTipPullSink: ?*ITipPullSink,
                o_ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipHelper,
                i_pszTxUrl: ?*u8,
                i_pTipPullSink: ?*ITipPullSink,
                o_ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLocalTmUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipHelper,
                o_ppszLocalTmUrl: ?*?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipHelper,
                o_ppszLocalTmUrl: ?*?*u8,
            ) 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 ITipHelper_Pull(self: *const T, i_pszTxUrl: ?*u8, o_ppITransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).Pull(@as(*const ITipHelper, @ptrCast(self)), i_pszTxUrl, o_ppITransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITipHelper_PullAsync(self: *const T, i_pszTxUrl: ?*u8, i_pTipPullSink: ?*ITipPullSink, o_ppITransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).PullAsync(@as(*const ITipHelper, @ptrCast(self)), i_pszTxUrl, i_pTipPullSink, o_ppITransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITipHelper_GetLocalTmUrl(self: *const T, o_ppszLocalTmUrl: ?*?*u8) HRESULT {
                return @as(*const ITipHelper.VTable, @ptrCast(self.vtable)).GetLocalTmUrl(@as(*const ITipHelper, @ptrCast(self)), o_ppszLocalTmUrl);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITipPullSink_Value = Guid.initString("17cf72d2-bac5-11d1-b1bf-00c04fc2f3ef");
pub const IID_ITipPullSink = &IID_ITipPullSink_Value;
pub const ITipPullSink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        PullComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITipPullSink,
                i_hrPull: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITipPullSink,
                i_hrPull: 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 ITipPullSink_PullComplete(self: *const T, i_hrPull: HRESULT) HRESULT {
                return @as(*const ITipPullSink.VTable, @ptrCast(self.vtable)).PullComplete(@as(*const ITipPullSink, @ptrCast(self)), i_hrPull);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcNetworkAccessConfig_Value = Guid.initString("9797c15d-a428-4291-87b6-0995031a678d");
pub const IID_IDtcNetworkAccessConfig = &IID_IDtcNetworkAccessConfig_Value;
pub const IDtcNetworkAccessConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetAnyNetworkAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbAnyNetworkAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbAnyNetworkAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAnyNetworkAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bAnyNetworkAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bAnyNetworkAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNetworkAdministrationAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkAdministrationAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkAdministrationAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkAdministrationAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkAdministrationAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkAdministrationAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNetworkTransactionAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkTransactionAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkTransactionAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkTransactionAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkTransactionAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkTransactionAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNetworkClientAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkClientAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkClientAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkClientAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkClientAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkClientAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNetworkTIPAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkTIPAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbNetworkTIPAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkTIPAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkTIPAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bNetworkTIPAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetXAAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                pbXAAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                pbXAAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetXAAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
                bXAAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
                bXAAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RestartDtcService: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig,
            ) 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 IDtcNetworkAccessConfig_GetAnyNetworkAccess(self: *const T, pbAnyNetworkAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetAnyNetworkAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbAnyNetworkAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetAnyNetworkAccess(self: *const T, bAnyNetworkAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetAnyNetworkAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bAnyNetworkAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_GetNetworkAdministrationAccess(self: *const T, pbNetworkAdministrationAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkAdministrationAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkAdministrationAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetNetworkAdministrationAccess(self: *const T, bNetworkAdministrationAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkAdministrationAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkAdministrationAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_GetNetworkTransactionAccess(self: *const T, pbNetworkTransactionAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkTransactionAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkTransactionAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetNetworkTransactionAccess(self: *const T, bNetworkTransactionAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkTransactionAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkTransactionAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_GetNetworkClientAccess(self: *const T, pbNetworkClientAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkClientAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkClientAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetNetworkClientAccess(self: *const T, bNetworkClientAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkClientAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkClientAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_GetNetworkTIPAccess(self: *const T, pbNetworkTIPAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetNetworkTIPAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbNetworkTIPAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetNetworkTIPAccess(self: *const T, bNetworkTIPAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetNetworkTIPAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bNetworkTIPAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_GetXAAccess(self: *const T, pbXAAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).GetXAAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), pbXAAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_SetXAAccess(self: *const T, bXAAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).SetXAAccess(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)), bXAAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig_RestartDtcService(self: *const T) HRESULT {
                return @as(*const IDtcNetworkAccessConfig.VTable, @ptrCast(self.vtable)).RestartDtcService(@as(*const IDtcNetworkAccessConfig, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const AUTHENTICATION_LEVEL = enum(i32) {
    NO_AUTHENTICATION_REQUIRED = 0,
    INCOMING_AUTHENTICATION_REQUIRED = 1,
    MUTUAL_AUTHENTICATION_REQUIRED = 2,
};
pub const NO_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.NO_AUTHENTICATION_REQUIRED;
pub const INCOMING_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.INCOMING_AUTHENTICATION_REQUIRED;
pub const MUTUAL_AUTHENTICATION_REQUIRED = AUTHENTICATION_LEVEL.MUTUAL_AUTHENTICATION_REQUIRED;

const IID_IDtcNetworkAccessConfig2_Value = Guid.initString("a7aa013b-eb7d-4f42-b41c-b2dec09ae034");
pub const IID_IDtcNetworkAccessConfig2 = &IID_IDtcNetworkAccessConfig2_Value;
pub const IDtcNetworkAccessConfig2 = extern struct {
    pub const VTable = extern struct {
        base: IDtcNetworkAccessConfig.VTable,
        GetNetworkInboundAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                pbInbound: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                pbInbound: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNetworkOutboundAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                pbOutbound: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                pbOutbound: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkInboundAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                bInbound: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                bInbound: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetNetworkOutboundAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                bOutbound: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                bOutbound: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAuthenticationLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                pAuthLevel: ?*AUTHENTICATION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                pAuthLevel: ?*AUTHENTICATION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAuthenticationLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig2,
                AuthLevel: AUTHENTICATION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig2,
                AuthLevel: AUTHENTICATION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDtcNetworkAccessConfig.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_GetNetworkInboundAccess(self: *const T, pbInbound: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetNetworkInboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pbInbound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_GetNetworkOutboundAccess(self: *const T, pbOutbound: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetNetworkOutboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pbOutbound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_SetNetworkInboundAccess(self: *const T, bInbound: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetNetworkInboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), bInbound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_SetNetworkOutboundAccess(self: *const T, bOutbound: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetNetworkOutboundAccess(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), bOutbound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_GetAuthenticationLevel(self: *const T, pAuthLevel: ?*AUTHENTICATION_LEVEL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).GetAuthenticationLevel(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), pAuthLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig2_SetAuthenticationLevel(self: *const T, AuthLevel: AUTHENTICATION_LEVEL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig2.VTable, @ptrCast(self.vtable)).SetAuthenticationLevel(@as(*const IDtcNetworkAccessConfig2, @ptrCast(self)), AuthLevel);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcNetworkAccessConfig3_Value = Guid.initString("76e4b4f3-2ca5-466b-89d5-fd218ee75b49");
pub const IID_IDtcNetworkAccessConfig3 = &IID_IDtcNetworkAccessConfig3_Value;
pub const IDtcNetworkAccessConfig3 = extern struct {
    pub const VTable = extern struct {
        base: IDtcNetworkAccessConfig2.VTable,
        GetLUAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig3,
                pbLUAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig3,
                pbLUAccess: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetLUAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcNetworkAccessConfig3,
                bLUAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcNetworkAccessConfig3,
                bLUAccess: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDtcNetworkAccessConfig2.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig3_GetLUAccess(self: *const T, pbLUAccess: ?*BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig3.VTable, @ptrCast(self.vtable)).GetLUAccess(@as(*const IDtcNetworkAccessConfig3, @ptrCast(self)), pbLUAccess);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcNetworkAccessConfig3_SetLUAccess(self: *const T, bLUAccess: BOOL) HRESULT {
                return @as(*const IDtcNetworkAccessConfig3.VTable, @ptrCast(self.vtable)).SetLUAccess(@as(*const IDtcNetworkAccessConfig3, @ptrCast(self)), bLUAccess);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const xid_t = extern struct {
    formatID: i32,
    gtrid_length: i32,
    bqual_length: i32,
    data: [128]CHAR,
};

pub const xa_switch_t = extern struct {
    name: [32]CHAR,
    flags: i32,
    version: i32,
    xa_open_entry: isize,
    xa_close_entry: isize,
    xa_start_entry: isize,
    xa_end_entry: isize,
    xa_rollback_entry: isize,
    xa_prepare_entry: isize,
    xa_commit_entry: isize,
    xa_recover_entry: isize,
    xa_forget_entry: isize,
    xa_complete_entry: isize,
};

pub const XA_OPEN_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?PSTR,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?PSTR,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_CLOSE_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?PSTR,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?PSTR,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_START_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_END_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_ROLLBACK_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_PREPARE_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_COMMIT_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_RECOVER_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
        param3: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
        param3: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_FORGET_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*xid_t,
        param1: i32,
        param2: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const XA_COMPLETE_EPT = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*i32,
        param1: ?*i32,
        param2: i32,
        param3: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*i32,
        param1: ?*i32,
        param2: i32,
        param3: i32,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

const IID_IDtcToXaMapper_Value = Guid.initString("64ffabe0-7ce9-11d0-8ce6-00c04fdc877e");
pub const IID_IDtcToXaMapper = &IID_IDtcToXaMapper_Value;
pub const IDtcToXaMapper = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        RequestNewResourceManager: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaMapper,
                pszDSN: ?PSTR,
                pszClientDllName: ?PSTR,
                pdwRMCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaMapper,
                pszDSN: ?PSTR,
                pszClientDllName: ?PSTR,
                pdwRMCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TranslateTridToXid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaMapper,
                pdwITransaction: ?*u32,
                dwRMCookie: u32,
                pXid: ?*xid_t,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaMapper,
                pdwITransaction: ?*u32,
                dwRMCookie: u32,
                pXid: ?*xid_t,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnlistResourceManager: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaMapper,
                dwRMCookie: u32,
                pdwITransaction: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaMapper,
                dwRMCookie: u32,
                pdwITransaction: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReleaseResourceManager: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaMapper,
                dwRMCookie: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaMapper,
                dwRMCookie: 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 IDtcToXaMapper_RequestNewResourceManager(self: *const T, pszDSN: ?PSTR, pszClientDllName: ?PSTR, pdwRMCookie: ?*u32) HRESULT {
                return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).RequestNewResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), pszDSN, pszClientDllName, pdwRMCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaMapper_TranslateTridToXid(self: *const T, pdwITransaction: ?*u32, dwRMCookie: u32, pXid: ?*xid_t) HRESULT {
                return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).TranslateTridToXid(@as(*const IDtcToXaMapper, @ptrCast(self)), pdwITransaction, dwRMCookie, pXid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaMapper_EnlistResourceManager(self: *const T, dwRMCookie: u32, pdwITransaction: ?*u32) HRESULT {
                return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).EnlistResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), dwRMCookie, pdwITransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaMapper_ReleaseResourceManager(self: *const T, dwRMCookie: u32) HRESULT {
                return @as(*const IDtcToXaMapper.VTable, @ptrCast(self.vtable)).ReleaseResourceManager(@as(*const IDtcToXaMapper, @ptrCast(self)), dwRMCookie);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcToXaHelperFactory_Value = Guid.initString("a9861610-304a-11d1-9813-00a0c905416e");
pub const IID_IDtcToXaHelperFactory = &IID_IDtcToXaHelperFactory_Value;
pub const IDtcToXaHelperFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelperFactory,
                pszDSN: ?PSTR,
                pszClientDllName: ?PSTR,
                pguidRm: ?*Guid,
                ppXaHelper: ?*?*IDtcToXaHelper,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelperFactory,
                pszDSN: ?PSTR,
                pszClientDllName: ?PSTR,
                pguidRm: ?*Guid,
                ppXaHelper: ?*?*IDtcToXaHelper,
            ) 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 IDtcToXaHelperFactory_Create(self: *const T, pszDSN: ?PSTR, pszClientDllName: ?PSTR, pguidRm: ?*Guid, ppXaHelper: ?*?*IDtcToXaHelper) HRESULT {
                return @as(*const IDtcToXaHelperFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcToXaHelperFactory, @ptrCast(self)), pszDSN, pszClientDllName, pguidRm, ppXaHelper);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcToXaHelper_Value = Guid.initString("a9861611-304a-11d1-9813-00a0c905416e");
pub const IID_IDtcToXaHelper = &IID_IDtcToXaHelper_Value;
pub const IDtcToXaHelper = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelper,
                i_fDoRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelper,
                i_fDoRecovery: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TranslateTridToXid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelper,
                pITransaction: ?*ITransaction,
                pguidBqual: ?*Guid,
                pXid: ?*xid_t,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelper,
                pITransaction: ?*ITransaction,
                pguidBqual: ?*Guid,
                pXid: ?*xid_t,
            ) 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 IDtcToXaHelper_Close(self: *const T, i_fDoRecovery: BOOL) HRESULT {
                return @as(*const IDtcToXaHelper.VTable, @ptrCast(self.vtable)).Close(@as(*const IDtcToXaHelper, @ptrCast(self)), i_fDoRecovery);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaHelper_TranslateTridToXid(self: *const T, pITransaction: ?*ITransaction, pguidBqual: ?*Guid, pXid: ?*xid_t) HRESULT {
                return @as(*const IDtcToXaHelper.VTable, @ptrCast(self.vtable)).TranslateTridToXid(@as(*const IDtcToXaHelper, @ptrCast(self)), pITransaction, pguidBqual, pXid);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcToXaHelperSinglePipe_Value = Guid.initString("47ed4971-53b3-11d1-bbb9-00c04fd658f6");
pub const IID_IDtcToXaHelperSinglePipe = &IID_IDtcToXaHelperSinglePipe_Value;
pub const IDtcToXaHelperSinglePipe = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        XARMCreate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelperSinglePipe,
                pszDSN: ?PSTR,
                pszClientDll: ?PSTR,
                pdwRMCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelperSinglePipe,
                pszDSN: ?PSTR,
                pszClientDll: ?PSTR,
                pdwRMCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ConvertTridToXID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelperSinglePipe,
                pdwITrans: ?*u32,
                dwRMCookie: u32,
                pxid: ?*xid_t,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelperSinglePipe,
                pdwITrans: ?*u32,
                dwRMCookie: u32,
                pxid: ?*xid_t,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnlistWithRM: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelperSinglePipe,
                dwRMCookie: u32,
                i_pITransaction: ?*ITransaction,
                i_pITransRes: ?*ITransactionResourceAsync,
                o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcToXaHelperSinglePipe,
                dwRMCookie: u32,
                i_pITransaction: ?*ITransaction,
                i_pITransRes: ?*ITransactionResourceAsync,
                o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReleaseRMCookie: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcToXaHelperSinglePipe,
                i_dwRMCookie: u32,
                i_fNormal: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IDtcToXaHelperSinglePipe,
                i_dwRMCookie: u32,
                i_fNormal: BOOL,
            ) 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 IDtcToXaHelperSinglePipe_XARMCreate(self: *const T, pszDSN: ?PSTR, pszClientDll: ?PSTR, pdwRMCookie: ?*u32) HRESULT {
                return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).XARMCreate(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), pszDSN, pszClientDll, pdwRMCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaHelperSinglePipe_ConvertTridToXID(self: *const T, pdwITrans: ?*u32, dwRMCookie: u32, pxid: ?*xid_t) HRESULT {
                return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).ConvertTridToXID(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), pdwITrans, dwRMCookie, pxid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaHelperSinglePipe_EnlistWithRM(self: *const T, dwRMCookie: u32, i_pITransaction: ?*ITransaction, i_pITransRes: ?*ITransactionResourceAsync, o_ppITransEnslitment: ?*?*ITransactionEnlistmentAsync) HRESULT {
                return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).EnlistWithRM(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), dwRMCookie, i_pITransaction, i_pITransRes, o_ppITransEnslitment);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcToXaHelperSinglePipe_ReleaseRMCookie(self: *const T, i_dwRMCookie: u32, i_fNormal: BOOL) void {
                return @as(*const IDtcToXaHelperSinglePipe.VTable, @ptrCast(self.vtable)).ReleaseRMCookie(@as(*const IDtcToXaHelperSinglePipe, @ptrCast(self)), i_dwRMCookie, i_fNormal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const APPLICATIONTYPE = enum(i32) {
    LOCAL_APPLICATIONTYPE = 0,
    CLUSTERRESOURCE_APPLICATIONTYPE = 1,
};
pub const LOCAL_APPLICATIONTYPE = APPLICATIONTYPE.LOCAL_APPLICATIONTYPE;
pub const CLUSTERRESOURCE_APPLICATIONTYPE = APPLICATIONTYPE.CLUSTERRESOURCE_APPLICATIONTYPE;

pub const OLE_TM_CONFIG_PARAMS_V1 = extern struct {
    dwVersion: u32,
    dwcConcurrencyHint: u32,
};

pub const OLE_TM_CONFIG_PARAMS_V2 = extern struct {
    dwVersion: u32,
    dwcConcurrencyHint: u32,
    applicationType: APPLICATIONTYPE,
    clusterResourceId: Guid,
};

pub const XACT_DTC_CONSTANTS = enum(i32) {
    XACT_E_CONNECTION_REQUEST_DENIED = -2147168000,
    XACT_E_TOOMANY_ENLISTMENTS = -2147167999,
    XACT_E_DUPLICATE_GUID = -2147167998,
    XACT_E_NOTSINGLEPHASE = -2147167997,
    XACT_E_RECOVERYALREADYDONE = -2147167996,
    XACT_E_PROTOCOL = -2147167995,
    XACT_E_RM_FAILURE = -2147167994,
    XACT_E_RECOVERY_FAILED = -2147167993,
    XACT_E_LU_NOT_FOUND = -2147167992,
    XACT_E_DUPLICATE_LU = -2147167991,
    XACT_E_LU_NOT_CONNECTED = -2147167990,
    XACT_E_DUPLICATE_TRANSID = -2147167989,
    XACT_E_LU_BUSY = -2147167988,
    XACT_E_LU_NO_RECOVERY_PROCESS = -2147167987,
    XACT_E_LU_DOWN = -2147167986,
    XACT_E_LU_RECOVERING = -2147167985,
    XACT_E_LU_RECOVERY_MISMATCH = -2147167984,
    XACT_E_RM_UNAVAILABLE = -2147167983,
    XACT_E_LRMRECOVERYALREADYDONE = -2147167982,
    XACT_E_NOLASTRESOURCEINTERFACE = -2147167981,
    XACT_S_NONOTIFY = 315648,
    XACT_OK_NONOTIFY = 315649,
    dwUSER_MS_SQLSERVER = 65535,
};
pub const XACT_E_CONNECTION_REQUEST_DENIED = XACT_DTC_CONSTANTS.XACT_E_CONNECTION_REQUEST_DENIED;
pub const XACT_E_TOOMANY_ENLISTMENTS = XACT_DTC_CONSTANTS.XACT_E_TOOMANY_ENLISTMENTS;
pub const XACT_E_DUPLICATE_GUID = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_GUID;
pub const XACT_E_NOTSINGLEPHASE = XACT_DTC_CONSTANTS.XACT_E_NOTSINGLEPHASE;
pub const XACT_E_RECOVERYALREADYDONE = XACT_DTC_CONSTANTS.XACT_E_RECOVERYALREADYDONE;
pub const XACT_E_PROTOCOL = XACT_DTC_CONSTANTS.XACT_E_PROTOCOL;
pub const XACT_E_RM_FAILURE = XACT_DTC_CONSTANTS.XACT_E_RM_FAILURE;
pub const XACT_E_RECOVERY_FAILED = XACT_DTC_CONSTANTS.XACT_E_RECOVERY_FAILED;
pub const XACT_E_LU_NOT_FOUND = XACT_DTC_CONSTANTS.XACT_E_LU_NOT_FOUND;
pub const XACT_E_DUPLICATE_LU = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_LU;
pub const XACT_E_LU_NOT_CONNECTED = XACT_DTC_CONSTANTS.XACT_E_LU_NOT_CONNECTED;
pub const XACT_E_DUPLICATE_TRANSID = XACT_DTC_CONSTANTS.XACT_E_DUPLICATE_TRANSID;
pub const XACT_E_LU_BUSY = XACT_DTC_CONSTANTS.XACT_E_LU_BUSY;
pub const XACT_E_LU_NO_RECOVERY_PROCESS = XACT_DTC_CONSTANTS.XACT_E_LU_NO_RECOVERY_PROCESS;
pub const XACT_E_LU_DOWN = XACT_DTC_CONSTANTS.XACT_E_LU_DOWN;
pub const XACT_E_LU_RECOVERING = XACT_DTC_CONSTANTS.XACT_E_LU_RECOVERING;
pub const XACT_E_LU_RECOVERY_MISMATCH = XACT_DTC_CONSTANTS.XACT_E_LU_RECOVERY_MISMATCH;
pub const XACT_E_RM_UNAVAILABLE = XACT_DTC_CONSTANTS.XACT_E_RM_UNAVAILABLE;
pub const XACT_E_LRMRECOVERYALREADYDONE = XACT_DTC_CONSTANTS.XACT_E_LRMRECOVERYALREADYDONE;
pub const XACT_E_NOLASTRESOURCEINTERFACE = XACT_DTC_CONSTANTS.XACT_E_NOLASTRESOURCEINTERFACE;
pub const XACT_S_NONOTIFY = XACT_DTC_CONSTANTS.XACT_S_NONOTIFY;
pub const XACT_OK_NONOTIFY = XACT_DTC_CONSTANTS.XACT_OK_NONOTIFY;
pub const dwUSER_MS_SQLSERVER = XACT_DTC_CONSTANTS.dwUSER_MS_SQLSERVER;

const IID_IXATransLookup_Value = Guid.initString("f3b1f131-eeda-11ce-aed4-00aa0051e2c4");
pub const IID_IXATransLookup = &IID_IXATransLookup_Value;
pub const IXATransLookup = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Lookup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXATransLookup,
                ppTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXATransLookup,
                ppTransaction: ?*?*ITransaction,
            ) 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 IXATransLookup_Lookup(self: *const T, ppTransaction: ?*?*ITransaction) HRESULT {
                return @as(*const IXATransLookup.VTable, @ptrCast(self.vtable)).Lookup(@as(*const IXATransLookup, @ptrCast(self)), ppTransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXATransLookup2_Value = Guid.initString("bf193c85-0d1a-4290-b88f-d2cb8873d1e7");
pub const IID_IXATransLookup2 = &IID_IXATransLookup2_Value;
pub const IXATransLookup2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Lookup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXATransLookup2,
                pXID: ?*xid_t,
                ppTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXATransLookup2,
                pXID: ?*xid_t,
                ppTransaction: ?*?*ITransaction,
            ) 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 IXATransLookup2_Lookup(self: *const T, pXID: ?*xid_t, ppTransaction: ?*?*ITransaction) HRESULT {
                return @as(*const IXATransLookup2.VTable, @ptrCast(self.vtable)).Lookup(@as(*const IXATransLookup2, @ptrCast(self)), pXID, ppTransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IResourceManagerSink_Value = Guid.initString("0d563181-defb-11ce-aed1-00aa0051e2c4");
pub const IID_IResourceManagerSink = &IID_IResourceManagerSink_Value;
pub const IResourceManagerSink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        TMDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManagerSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManagerSink,
            ) 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 IResourceManagerSink_TMDown(self: *const T) HRESULT {
                return @as(*const IResourceManagerSink.VTable, @ptrCast(self.vtable)).TMDown(@as(*const IResourceManagerSink, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.0'
const IID_IResourceManager_Value = Guid.initString("13741d21-87eb-11ce-8081-0080c758527e");
pub const IID_IResourceManager = &IID_IResourceManager_Value;
pub const IResourceManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Enlist: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager,
                pTransaction: ?*ITransaction,
                pRes: ?*ITransactionResourceAsync,
                pUOW: ?*BOID,
                pisoLevel: ?*i32,
                ppEnlist: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager,
                pTransaction: ?*ITransaction,
                pRes: ?*ITransactionResourceAsync,
                pUOW: ?*BOID,
                pisoLevel: ?*i32,
                ppEnlist: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reenlist: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
                lTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
                lTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReenlistmentComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDistributedTransactionManager: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager,
                iid: ?*const Guid,
                ppvObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager,
                iid: ?*const Guid,
                ppvObject: ?*?*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 IResourceManager_Enlist(self: *const T, pTransaction: ?*ITransaction, pRes: ?*ITransactionResourceAsync, pUOW: ?*BOID, pisoLevel: ?*i32, ppEnlist: ?*?*ITransactionEnlistmentAsync) HRESULT {
                return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).Enlist(@as(*const IResourceManager, @ptrCast(self)), pTransaction, pRes, pUOW, pisoLevel, ppEnlist);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManager_Reenlist(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32, lTimeout: u32, pXactStat: ?*XACTSTAT) HRESULT {
                return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).Reenlist(@as(*const IResourceManager, @ptrCast(self)), pPrepInfo, cbPrepInfo, lTimeout, pXactStat);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManager_ReenlistmentComplete(self: *const T) HRESULT {
                return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).ReenlistmentComplete(@as(*const IResourceManager, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManager_GetDistributedTransactionManager(self: *const T, iid: ?*const Guid, ppvObject: ?*?*anyopaque) HRESULT {
                return @as(*const IResourceManager.VTable, @ptrCast(self.vtable)).GetDistributedTransactionManager(@as(*const IResourceManager, @ptrCast(self)), iid, ppvObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ILastResourceManager_Value = Guid.initString("4d964ad4-5b33-11d3-8a91-00c04f79eb6d");
pub const IID_ILastResourceManager = &IID_ILastResourceManager_Value;
pub const ILastResourceManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        TransactionCommitted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILastResourceManager,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILastResourceManager,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RecoveryDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILastResourceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILastResourceManager,
            ) 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 ILastResourceManager_TransactionCommitted(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32) HRESULT {
                return @as(*const ILastResourceManager.VTable, @ptrCast(self.vtable)).TransactionCommitted(@as(*const ILastResourceManager, @ptrCast(self)), pPrepInfo, cbPrepInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILastResourceManager_RecoveryDone(self: *const T) HRESULT {
                return @as(*const ILastResourceManager.VTable, @ptrCast(self.vtable)).RecoveryDone(@as(*const ILastResourceManager, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IResourceManager2_Value = Guid.initString("d136c69a-f749-11d1-8f47-00c04f8ee57d");
pub const IID_IResourceManager2 = &IID_IResourceManager2_Value;
pub const IResourceManager2 = extern struct {
    pub const VTable = extern struct {
        base: IResourceManager.VTable,
        Enlist2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager2,
                pTransaction: ?*ITransaction,
                pResAsync: ?*ITransactionResourceAsync,
                pUOW: ?*BOID,
                pisoLevel: ?*i32,
                pXid: ?*xid_t,
                ppEnlist: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager2,
                pTransaction: ?*ITransaction,
                pResAsync: ?*ITransactionResourceAsync,
                pUOW: ?*BOID,
                pisoLevel: ?*i32,
                pXid: ?*xid_t,
                ppEnlist: ?*?*ITransactionEnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reenlist2: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManager2,
                pXid: ?*xid_t,
                dwTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManager2,
                pXid: ?*xid_t,
                dwTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IResourceManager.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManager2_Enlist2(self: *const T, pTransaction: ?*ITransaction, pResAsync: ?*ITransactionResourceAsync, pUOW: ?*BOID, pisoLevel: ?*i32, pXid: ?*xid_t, ppEnlist: ?*?*ITransactionEnlistmentAsync) HRESULT {
                return @as(*const IResourceManager2.VTable, @ptrCast(self.vtable)).Enlist2(@as(*const IResourceManager2, @ptrCast(self)), pTransaction, pResAsync, pUOW, pisoLevel, pXid, ppEnlist);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManager2_Reenlist2(self: *const T, pXid: ?*xid_t, dwTimeout: u32, pXactStat: ?*XACTSTAT) HRESULT {
                return @as(*const IResourceManager2.VTable, @ptrCast(self.vtable)).Reenlist2(@as(*const IResourceManager2, @ptrCast(self)), pXid, dwTimeout, pXactStat);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IResourceManagerRejoinable_Value = Guid.initString("6f6de620-b5df-4f3e-9cfa-c8aebd05172b");
pub const IID_IResourceManagerRejoinable = &IID_IResourceManagerRejoinable_Value;
pub const IResourceManagerRejoinable = extern struct {
    pub const VTable = extern struct {
        base: IResourceManager2.VTable,
        Rejoin: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManagerRejoinable,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
                lTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManagerRejoinable,
                pPrepInfo: [*:0]u8,
                cbPrepInfo: u32,
                lTimeout: u32,
                pXactStat: ?*XACTSTAT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IResourceManager2.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManagerRejoinable_Rejoin(self: *const T, pPrepInfo: [*:0]u8, cbPrepInfo: u32, lTimeout: u32, pXactStat: ?*XACTSTAT) HRESULT {
                return @as(*const IResourceManagerRejoinable.VTable, @ptrCast(self.vtable)).Rejoin(@as(*const IResourceManagerRejoinable, @ptrCast(self)), pPrepInfo, cbPrepInfo, lTimeout, pXactStat);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXAConfig_Value = Guid.initString("c8a6e3a1-9a8c-11cf-a308-00a0c905416e");
pub const IID_IXAConfig = &IID_IXAConfig_Value;
pub const IXAConfig = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXAConfig,
                clsidHelperDll: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXAConfig,
                clsidHelperDll: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Terminate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXAConfig,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXAConfig,
            ) 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 IXAConfig_Initialize(self: *const T, clsidHelperDll: Guid) HRESULT {
                return @as(*const IXAConfig.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IXAConfig, @ptrCast(self)), clsidHelperDll);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXAConfig_Terminate(self: *const T) HRESULT {
                return @as(*const IXAConfig.VTable, @ptrCast(self.vtable)).Terminate(@as(*const IXAConfig, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IRMHelper_Value = Guid.initString("e793f6d1-f53d-11cf-a60d-00a0c905416e");
pub const IID_IRMHelper = &IID_IRMHelper_Value;
pub const IRMHelper = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        RMCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRMHelper,
                dwcTotalNumberOfRMs: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRMHelper,
                dwcTotalNumberOfRMs: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RMInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRMHelper,
                pXa_Switch: ?*xa_switch_t,
                fCDeclCallingConv: BOOL,
                pszOpenString: ?PSTR,
                pszCloseString: ?PSTR,
                guidRMRecovery: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRMHelper,
                pXa_Switch: ?*xa_switch_t,
                fCDeclCallingConv: BOOL,
                pszOpenString: ?PSTR,
                pszCloseString: ?PSTR,
                guidRMRecovery: 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 IRMHelper_RMCount(self: *const T, dwcTotalNumberOfRMs: u32) HRESULT {
                return @as(*const IRMHelper.VTable, @ptrCast(self.vtable)).RMCount(@as(*const IRMHelper, @ptrCast(self)), dwcTotalNumberOfRMs);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRMHelper_RMInfo(self: *const T, pXa_Switch: ?*xa_switch_t, fCDeclCallingConv: BOOL, pszOpenString: ?PSTR, pszCloseString: ?PSTR, guidRMRecovery: Guid) HRESULT {
                return @as(*const IRMHelper.VTable, @ptrCast(self.vtable)).RMInfo(@as(*const IRMHelper, @ptrCast(self)), pXa_Switch, fCDeclCallingConv, pszOpenString, pszCloseString, guidRMRecovery);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXAObtainRMInfo_Value = Guid.initString("e793f6d2-f53d-11cf-a60d-00a0c905416e");
pub const IID_IXAObtainRMInfo = &IID_IXAObtainRMInfo_Value;
pub const IXAObtainRMInfo = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ObtainRMInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXAObtainRMInfo,
                pIRMHelper: ?*IRMHelper,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXAObtainRMInfo,
                pIRMHelper: ?*IRMHelper,
            ) 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 IXAObtainRMInfo_ObtainRMInfo(self: *const T, pIRMHelper: ?*IRMHelper) HRESULT {
                return @as(*const IXAObtainRMInfo.VTable, @ptrCast(self.vtable)).ObtainRMInfo(@as(*const IXAObtainRMInfo, @ptrCast(self)), pIRMHelper);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IResourceManagerFactory_Value = Guid.initString("13741d20-87eb-11ce-8081-0080c758527e");
pub const IID_IResourceManagerFactory = &IID_IResourceManagerFactory_Value;
pub const IResourceManagerFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManagerFactory,
                pguidRM: ?*Guid,
                pszRMName: ?PSTR,
                pIResMgrSink: ?*IResourceManagerSink,
                ppResMgr: ?*?*IResourceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManagerFactory,
                pguidRM: ?*Guid,
                pszRMName: ?PSTR,
                pIResMgrSink: ?*IResourceManagerSink,
                ppResMgr: ?*?*IResourceManager,
            ) 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 IResourceManagerFactory_Create(self: *const T, pguidRM: ?*Guid, pszRMName: ?PSTR, pIResMgrSink: ?*IResourceManagerSink, ppResMgr: ?*?*IResourceManager) HRESULT {
                return @as(*const IResourceManagerFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IResourceManagerFactory, @ptrCast(self)), pguidRM, pszRMName, pIResMgrSink, ppResMgr);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IResourceManagerFactory2_Value = Guid.initString("6b369c21-fbd2-11d1-8f47-00c04f8ee57d");
pub const IID_IResourceManagerFactory2 = &IID_IResourceManagerFactory2_Value;
pub const IResourceManagerFactory2 = extern struct {
    pub const VTable = extern struct {
        base: IResourceManagerFactory.VTable,
        CreateEx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IResourceManagerFactory2,
                pguidRM: ?*Guid,
                pszRMName: ?PSTR,
                pIResMgrSink: ?*IResourceManagerSink,
                riidRequested: ?*const Guid,
                ppvResMgr: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IResourceManagerFactory2,
                pguidRM: ?*Guid,
                pszRMName: ?PSTR,
                pIResMgrSink: ?*IResourceManagerSink,
                riidRequested: ?*const Guid,
                ppvResMgr: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IResourceManagerFactory.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IResourceManagerFactory2_CreateEx(self: *const T, pguidRM: ?*Guid, pszRMName: ?PSTR, pIResMgrSink: ?*IResourceManagerSink, riidRequested: ?*const Guid, ppvResMgr: ?*?*anyopaque) HRESULT {
                return @as(*const IResourceManagerFactory2.VTable, @ptrCast(self.vtable)).CreateEx(@as(*const IResourceManagerFactory2, @ptrCast(self)), pguidRM, pszRMName, pIResMgrSink, riidRequested, ppvResMgr);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPrepareInfo_Value = Guid.initString("80c7bfd0-87ee-11ce-8081-0080c758527e");
pub const IID_IPrepareInfo = &IID_IPrepareInfo_Value;
pub const IPrepareInfo = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetPrepareInfoSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPrepareInfo,
                pcbPrepInfo: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPrepareInfo,
                pcbPrepInfo: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPrepareInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPrepareInfo,
                pPrepInfo: ?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPrepareInfo,
                pPrepInfo: ?*u8,
            ) 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 IPrepareInfo_GetPrepareInfoSize(self: *const T, pcbPrepInfo: ?*u32) HRESULT {
                return @as(*const IPrepareInfo.VTable, @ptrCast(self.vtable)).GetPrepareInfoSize(@as(*const IPrepareInfo, @ptrCast(self)), pcbPrepInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPrepareInfo_GetPrepareInfo(self: *const T, pPrepInfo: ?*u8) HRESULT {
                return @as(*const IPrepareInfo.VTable, @ptrCast(self.vtable)).GetPrepareInfo(@as(*const IPrepareInfo, @ptrCast(self)), pPrepInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPrepareInfo2_Value = Guid.initString("5fab2547-9779-11d1-b886-00c04fb9618a");
pub const IID_IPrepareInfo2 = &IID_IPrepareInfo2_Value;
pub const IPrepareInfo2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetPrepareInfoSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPrepareInfo2,
                pcbPrepInfo: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPrepareInfo2,
                pcbPrepInfo: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPrepareInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPrepareInfo2,
                cbPrepareInfo: u32,
                pPrepInfo: [*:0]u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPrepareInfo2,
                cbPrepareInfo: u32,
                pPrepInfo: [*:0]u8,
            ) 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 IPrepareInfo2_GetPrepareInfoSize(self: *const T, pcbPrepInfo: ?*u32) HRESULT {
                return @as(*const IPrepareInfo2.VTable, @ptrCast(self.vtable)).GetPrepareInfoSize(@as(*const IPrepareInfo2, @ptrCast(self)), pcbPrepInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPrepareInfo2_GetPrepareInfo(self: *const T, cbPrepareInfo: u32, pPrepInfo: [*:0]u8) HRESULT {
                return @as(*const IPrepareInfo2.VTable, @ptrCast(self.vtable)).GetPrepareInfo(@as(*const IPrepareInfo2, @ptrCast(self)), cbPrepareInfo, pPrepInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IGetDispenser_Value = Guid.initString("c23cc370-87ef-11ce-8081-0080c758527e");
pub const IID_IGetDispenser = &IID_IGetDispenser_Value;
pub const IGetDispenser = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetDispenser: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGetDispenser,
                iid: ?*const Guid,
                ppvObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGetDispenser,
                iid: ?*const Guid,
                ppvObject: ?*?*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 IGetDispenser_GetDispenser(self: *const T, iid: ?*const Guid, ppvObject: ?*?*anyopaque) HRESULT {
                return @as(*const IGetDispenser.VTable, @ptrCast(self.vtable)).GetDispenser(@as(*const IGetDispenser, @ptrCast(self)), iid, ppvObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionVoterBallotAsync2_Value = Guid.initString("5433376c-414d-11d3-b206-00c04fc2f3ef");
pub const IID_ITransactionVoterBallotAsync2 = &IID_ITransactionVoterBallotAsync2_Value;
pub const ITransactionVoterBallotAsync2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        VoteRequestDone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionVoterBallotAsync2,
                hr: HRESULT,
                pboidReason: ?*BOID,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionVoterBallotAsync2,
                hr: HRESULT,
                pboidReason: ?*BOID,
            ) 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 ITransactionVoterBallotAsync2_VoteRequestDone(self: *const T, hr: HRESULT, pboidReason: ?*BOID) HRESULT {
                return @as(*const ITransactionVoterBallotAsync2.VTable, @ptrCast(self.vtable)).VoteRequestDone(@as(*const ITransactionVoterBallotAsync2, @ptrCast(self)), hr, pboidReason);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionVoterNotifyAsync2_Value = Guid.initString("5433376b-414d-11d3-b206-00c04fc2f3ef");
pub const IID_ITransactionVoterNotifyAsync2 = &IID_ITransactionVoterNotifyAsync2_Value;
pub const ITransactionVoterNotifyAsync2 = extern struct {
    pub const VTable = extern struct {
        base: ITransactionOutcomeEvents.VTable,
        VoteRequest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionVoterNotifyAsync2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionVoterNotifyAsync2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace ITransactionOutcomeEvents.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionVoterNotifyAsync2_VoteRequest(self: *const T) HRESULT {
                return @as(*const ITransactionVoterNotifyAsync2.VTable, @ptrCast(self.vtable)).VoteRequest(@as(*const ITransactionVoterNotifyAsync2, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionVoterFactory2_Value = Guid.initString("5433376a-414d-11d3-b206-00c04fc2f3ef");
pub const IID_ITransactionVoterFactory2 = &IID_ITransactionVoterFactory2_Value;
pub const ITransactionVoterFactory2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionVoterFactory2,
                pTransaction: ?*ITransaction,
                pVoterNotify: ?*ITransactionVoterNotifyAsync2,
                ppVoterBallot: ?*?*ITransactionVoterBallotAsync2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionVoterFactory2,
                pTransaction: ?*ITransaction,
                pVoterNotify: ?*ITransactionVoterNotifyAsync2,
                ppVoterBallot: ?*?*ITransactionVoterBallotAsync2,
            ) 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 ITransactionVoterFactory2_Create(self: *const T, pTransaction: ?*ITransaction, pVoterNotify: ?*ITransactionVoterNotifyAsync2, ppVoterBallot: ?*?*ITransactionVoterBallotAsync2) HRESULT {
                return @as(*const ITransactionVoterFactory2.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionVoterFactory2, @ptrCast(self)), pTransaction, pVoterNotify, ppVoterBallot);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionPhase0EnlistmentAsync_Value = Guid.initString("82dc88e1-a954-11d1-8f88-00600895e7d5");
pub const IID_ITransactionPhase0EnlistmentAsync = &IID_ITransactionPhase0EnlistmentAsync_Value;
pub const ITransactionPhase0EnlistmentAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Enable: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WaitForEnlistment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Phase0Done: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unenlist: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTransaction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0EnlistmentAsync,
                ppITransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0EnlistmentAsync,
                ppITransaction: ?*?*ITransaction,
            ) 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 ITransactionPhase0EnlistmentAsync_Enable(self: *const T) HRESULT {
                return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Enable(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionPhase0EnlistmentAsync_WaitForEnlistment(self: *const T) HRESULT {
                return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).WaitForEnlistment(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionPhase0EnlistmentAsync_Phase0Done(self: *const T) HRESULT {
                return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Phase0Done(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionPhase0EnlistmentAsync_Unenlist(self: *const T) HRESULT {
                return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).Unenlist(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionPhase0EnlistmentAsync_GetTransaction(self: *const T, ppITransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITransactionPhase0EnlistmentAsync.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const ITransactionPhase0EnlistmentAsync, @ptrCast(self)), ppITransaction);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionPhase0NotifyAsync_Value = Guid.initString("ef081809-0c76-11d2-87a6-00c04f990f34");
pub const IID_ITransactionPhase0NotifyAsync = &IID_ITransactionPhase0NotifyAsync_Value;
pub const ITransactionPhase0NotifyAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Phase0Request: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0NotifyAsync,
                fAbortingHint: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0NotifyAsync,
                fAbortingHint: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnlistCompleted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0NotifyAsync,
                status: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0NotifyAsync,
                status: 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 ITransactionPhase0NotifyAsync_Phase0Request(self: *const T, fAbortingHint: BOOL) HRESULT {
                return @as(*const ITransactionPhase0NotifyAsync.VTable, @ptrCast(self.vtable)).Phase0Request(@as(*const ITransactionPhase0NotifyAsync, @ptrCast(self)), fAbortingHint);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionPhase0NotifyAsync_EnlistCompleted(self: *const T, status: HRESULT) HRESULT {
                return @as(*const ITransactionPhase0NotifyAsync.VTable, @ptrCast(self.vtable)).EnlistCompleted(@as(*const ITransactionPhase0NotifyAsync, @ptrCast(self)), status);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionPhase0Factory_Value = Guid.initString("82dc88e0-a954-11d1-8f88-00600895e7d5");
pub const IID_ITransactionPhase0Factory = &IID_ITransactionPhase0Factory_Value;
pub const ITransactionPhase0Factory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionPhase0Factory,
                pPhase0Notify: ?*ITransactionPhase0NotifyAsync,
                ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionPhase0Factory,
                pPhase0Notify: ?*ITransactionPhase0NotifyAsync,
                ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync,
            ) 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 ITransactionPhase0Factory_Create(self: *const T, pPhase0Notify: ?*ITransactionPhase0NotifyAsync, ppPhase0Enlistment: ?*?*ITransactionPhase0EnlistmentAsync) HRESULT {
                return @as(*const ITransactionPhase0Factory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionPhase0Factory, @ptrCast(self)), pPhase0Notify, ppPhase0Enlistment);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionTransmitter_Value = Guid.initString("59313e01-b36c-11cf-a539-00aa006887c3");
pub const IID_ITransactionTransmitter = &IID_ITransactionTransmitter_Value;
pub const ITransactionTransmitter = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Set: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitter,
                pTransaction: ?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitter,
                pTransaction: ?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropagationTokenSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitter,
                pcbToken: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitter,
                pcbToken: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MarshalPropagationToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitter,
                cbToken: u32,
                rgbToken: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitter,
                cbToken: u32,
                rgbToken: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UnmarshalReturnToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitter,
                cbReturnToken: u32,
                rgbReturnToken: [*:0]u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitter,
                cbReturnToken: u32,
                rgbReturnToken: [*:0]u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitter,
            ) 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 ITransactionTransmitter_Set(self: *const T, pTransaction: ?*ITransaction) HRESULT {
                return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).Set(@as(*const ITransactionTransmitter, @ptrCast(self)), pTransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionTransmitter_GetPropagationTokenSize(self: *const T, pcbToken: ?*u32) HRESULT {
                return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).GetPropagationTokenSize(@as(*const ITransactionTransmitter, @ptrCast(self)), pcbToken);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionTransmitter_MarshalPropagationToken(self: *const T, cbToken: u32, rgbToken: [*:0]u8, pcbUsed: ?*u32) HRESULT {
                return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).MarshalPropagationToken(@as(*const ITransactionTransmitter, @ptrCast(self)), cbToken, rgbToken, pcbUsed);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionTransmitter_UnmarshalReturnToken(self: *const T, cbReturnToken: u32, rgbReturnToken: [*:0]u8) HRESULT {
                return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).UnmarshalReturnToken(@as(*const ITransactionTransmitter, @ptrCast(self)), cbReturnToken, rgbReturnToken);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionTransmitter_Reset(self: *const T) HRESULT {
                return @as(*const ITransactionTransmitter.VTable, @ptrCast(self.vtable)).Reset(@as(*const ITransactionTransmitter, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionTransmitterFactory_Value = Guid.initString("59313e00-b36c-11cf-a539-00aa006887c3");
pub const IID_ITransactionTransmitterFactory = &IID_ITransactionTransmitterFactory_Value;
pub const ITransactionTransmitterFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionTransmitterFactory,
                ppTransmitter: ?*?*ITransactionTransmitter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionTransmitterFactory,
                ppTransmitter: ?*?*ITransactionTransmitter,
            ) 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 ITransactionTransmitterFactory_Create(self: *const T, ppTransmitter: ?*?*ITransactionTransmitter) HRESULT {
                return @as(*const ITransactionTransmitterFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionTransmitterFactory, @ptrCast(self)), ppTransmitter);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionReceiver_Value = Guid.initString("59313e03-b36c-11cf-a539-00aa006887c3");
pub const IID_ITransactionReceiver = &IID_ITransactionReceiver_Value;
pub const ITransactionReceiver = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        UnmarshalPropagationToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionReceiver,
                cbToken: u32,
                rgbToken: [*:0]u8,
                ppTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionReceiver,
                cbToken: u32,
                rgbToken: [*:0]u8,
                ppTransaction: ?*?*ITransaction,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetReturnTokenSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionReceiver,
                pcbReturnToken: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionReceiver,
                pcbReturnToken: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MarshalReturnToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionReceiver,
                cbReturnToken: u32,
                rgbReturnToken: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionReceiver,
                cbReturnToken: u32,
                rgbReturnToken: [*:0]u8,
                pcbUsed: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionReceiver,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionReceiver,
            ) 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 ITransactionReceiver_UnmarshalPropagationToken(self: *const T, cbToken: u32, rgbToken: [*:0]u8, ppTransaction: ?*?*ITransaction) HRESULT {
                return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).UnmarshalPropagationToken(@as(*const ITransactionReceiver, @ptrCast(self)), cbToken, rgbToken, ppTransaction);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionReceiver_GetReturnTokenSize(self: *const T, pcbReturnToken: ?*u32) HRESULT {
                return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).GetReturnTokenSize(@as(*const ITransactionReceiver, @ptrCast(self)), pcbReturnToken);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionReceiver_MarshalReturnToken(self: *const T, cbReturnToken: u32, rgbReturnToken: [*:0]u8, pcbUsed: ?*u32) HRESULT {
                return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).MarshalReturnToken(@as(*const ITransactionReceiver, @ptrCast(self)), cbReturnToken, rgbReturnToken, pcbUsed);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ITransactionReceiver_Reset(self: *const T) HRESULT {
                return @as(*const ITransactionReceiver.VTable, @ptrCast(self.vtable)).Reset(@as(*const ITransactionReceiver, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_ITransactionReceiverFactory_Value = Guid.initString("59313e02-b36c-11cf-a539-00aa006887c3");
pub const IID_ITransactionReceiverFactory = &IID_ITransactionReceiverFactory_Value;
pub const ITransactionReceiverFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ITransactionReceiverFactory,
                ppReceiver: ?*?*ITransactionReceiver,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ITransactionReceiverFactory,
                ppReceiver: ?*?*ITransactionReceiver,
            ) 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 ITransactionReceiverFactory_Create(self: *const T, ppReceiver: ?*?*ITransactionReceiver) HRESULT {
                return @as(*const ITransactionReceiverFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const ITransactionReceiverFactory, @ptrCast(self)), ppReceiver);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const _ProxyConfigParams = extern struct {
    wcThreadsMax: u16,
};

const IID_IDtcLuConfigure_Value = Guid.initString("4131e760-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuConfigure = &IID_IDtcLuConfigure_Value;
pub const IDtcLuConfigure = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuConfigure,
                pucLuPair: [*:0]u8,
                cbLuPair: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuConfigure,
                pucLuPair: [*:0]u8,
                cbLuPair: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuConfigure,
                pucLuPair: [*:0]u8,
                cbLuPair: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuConfigure,
                pucLuPair: [*:0]u8,
                cbLuPair: 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 IDtcLuConfigure_Add(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32) HRESULT {
                return @as(*const IDtcLuConfigure.VTable, @ptrCast(self.vtable)).Add(@as(*const IDtcLuConfigure, @ptrCast(self)), pucLuPair, cbLuPair);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuConfigure_Delete(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32) HRESULT {
                return @as(*const IDtcLuConfigure.VTable, @ptrCast(self.vtable)).Delete(@as(*const IDtcLuConfigure, @ptrCast(self)), pucLuPair, cbLuPair);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecovery_Value = Guid.initString("ac2b8ad2-d6f0-11d0-b386-00a0c9083365");
pub const IID_IDtcLuRecovery = &IID_IDtcLuRecovery_Value;
pub const IDtcLuRecovery = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecoveryFactory_Value = Guid.initString("4131e762-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRecoveryFactory = &IID_IDtcLuRecoveryFactory_Value;
pub const IDtcLuRecoveryFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryFactory,
                pucLuPair: [*:0]u8,
                cbLuPair: u32,
                ppRecovery: ?*?*IDtcLuRecovery,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryFactory,
                pucLuPair: [*:0]u8,
                cbLuPair: u32,
                ppRecovery: ?*?*IDtcLuRecovery,
            ) 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 IDtcLuRecoveryFactory_Create(self: *const T, pucLuPair: [*:0]u8, cbLuPair: u32, ppRecovery: ?*?*IDtcLuRecovery) HRESULT {
                return @as(*const IDtcLuRecoveryFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuRecoveryFactory, @ptrCast(self)), pucLuPair, cbLuPair, ppRecovery);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const _DtcLu_LocalRecovery_Work = enum(i32) {
    CHECKLUSTATUS = 1,
    TRANS = 2,
    TMDOWN = 3,
};
pub const DTCINITIATEDRECOVERYWORK_CHECKLUSTATUS = _DtcLu_LocalRecovery_Work.CHECKLUSTATUS;
pub const DTCINITIATEDRECOVERYWORK_TRANS = _DtcLu_LocalRecovery_Work.TRANS;
pub const DTCINITIATEDRECOVERYWORK_TMDOWN = _DtcLu_LocalRecovery_Work.TMDOWN;

pub const _DtcLu_Xln = enum(i32) {
    COLD = 1,
    WARM = 2,
};
pub const DTCLUXLN_COLD = _DtcLu_Xln.COLD;
pub const DTCLUXLN_WARM = _DtcLu_Xln.WARM;

pub const _DtcLu_Xln_Confirmation = enum(i32) {
    CONFIRM = 1,
    LOGNAMEMISMATCH = 2,
    COLDWARMMISMATCH = 3,
    OBSOLETE = 4,
};
pub const DTCLUXLNCONFIRMATION_CONFIRM = _DtcLu_Xln_Confirmation.CONFIRM;
pub const DTCLUXLNCONFIRMATION_LOGNAMEMISMATCH = _DtcLu_Xln_Confirmation.LOGNAMEMISMATCH;
pub const DTCLUXLNCONFIRMATION_COLDWARMMISMATCH = _DtcLu_Xln_Confirmation.COLDWARMMISMATCH;
pub const DTCLUXLNCONFIRMATION_OBSOLETE = _DtcLu_Xln_Confirmation.OBSOLETE;

pub const _DtcLu_Xln_Response = enum(i32) {
    OK_SENDOURXLNBACK = 1,
    OK_SENDCONFIRMATION = 2,
    LOGNAMEMISMATCH = 3,
    COLDWARMMISMATCH = 4,
};
pub const DTCLUXLNRESPONSE_OK_SENDOURXLNBACK = _DtcLu_Xln_Response.OK_SENDOURXLNBACK;
pub const DTCLUXLNRESPONSE_OK_SENDCONFIRMATION = _DtcLu_Xln_Response.OK_SENDCONFIRMATION;
pub const DTCLUXLNRESPONSE_LOGNAMEMISMATCH = _DtcLu_Xln_Response.LOGNAMEMISMATCH;
pub const DTCLUXLNRESPONSE_COLDWARMMISMATCH = _DtcLu_Xln_Response.COLDWARMMISMATCH;

pub const _DtcLu_Xln_Error = enum(i32) {
    PROTOCOL = 1,
    LOGNAMEMISMATCH = 2,
    COLDWARMMISMATCH = 3,
};
pub const DTCLUXLNERROR_PROTOCOL = _DtcLu_Xln_Error.PROTOCOL;
pub const DTCLUXLNERROR_LOGNAMEMISMATCH = _DtcLu_Xln_Error.LOGNAMEMISMATCH;
pub const DTCLUXLNERROR_COLDWARMMISMATCH = _DtcLu_Xln_Error.COLDWARMMISMATCH;

pub const _DtcLu_CompareState = enum(i32) {
    COMMITTED = 1,
    HEURISTICCOMMITTED = 2,
    HEURISTICMIXED = 3,
    HEURISTICRESET = 4,
    INDOUBT = 5,
    RESET = 6,
};
pub const DTCLUCOMPARESTATE_COMMITTED = _DtcLu_CompareState.COMMITTED;
pub const DTCLUCOMPARESTATE_HEURISTICCOMMITTED = _DtcLu_CompareState.HEURISTICCOMMITTED;
pub const DTCLUCOMPARESTATE_HEURISTICMIXED = _DtcLu_CompareState.HEURISTICMIXED;
pub const DTCLUCOMPARESTATE_HEURISTICRESET = _DtcLu_CompareState.HEURISTICRESET;
pub const DTCLUCOMPARESTATE_INDOUBT = _DtcLu_CompareState.INDOUBT;
pub const DTCLUCOMPARESTATE_RESET = _DtcLu_CompareState.RESET;

pub const _DtcLu_CompareStates_Confirmation = enum(i32) {
    CONFIRM = 1,
    PROTOCOL = 2,
};
pub const DTCLUCOMPARESTATESCONFIRMATION_CONFIRM = _DtcLu_CompareStates_Confirmation.CONFIRM;
pub const DTCLUCOMPARESTATESCONFIRMATION_PROTOCOL = _DtcLu_CompareStates_Confirmation.PROTOCOL;

pub const _DtcLu_CompareStates_Error = enum(i32) {
    L = 1,
};
pub const DTCLUCOMPARESTATESERROR_PROTOCOL = _DtcLu_CompareStates_Error.L;

pub const _DtcLu_CompareStates_Response = enum(i32) {
    OK = 1,
    PROTOCOL = 2,
};
pub const DTCLUCOMPARESTATESRESPONSE_OK = _DtcLu_CompareStates_Response.OK;
pub const DTCLUCOMPARESTATESRESPONSE_PROTOCOL = _DtcLu_CompareStates_Response.PROTOCOL;

const IID_IDtcLuRecoveryInitiatedByDtcTransWork_Value = Guid.initString("4131e765-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRecoveryInitiatedByDtcTransWork = &IID_IDtcLuRecoveryInitiatedByDtcTransWork_Value;
pub const IDtcLuRecoveryInitiatedByDtcTransWork = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetLogNameSizes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pcbOurLogName: ?*u32,
                pcbRemoteLogName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pcbOurLogName: ?*u32,
                pcbRemoteLogName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOurXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pXln: ?*_DtcLu_Xln,
                pOurLogName: ?*u8,
                pRemoteLogName: ?*u8,
                pdwProtocol: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pXln: ?*_DtcLu_Xln,
                pOurLogName: ?*u8,
                pRemoteLogName: ?*u8,
                pdwProtocol: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleConfirmationFromOurXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Confirmation: _DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Confirmation: _DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleTheirXlnResponse: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Xln: _DtcLu_Xln,
                pRemoteLogName: ?*u8,
                cbRemoteLogName: u32,
                dwProtocol: u32,
                pConfirmation: ?*_DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Xln: _DtcLu_Xln,
                pRemoteLogName: ?*u8,
                cbRemoteLogName: u32,
                dwProtocol: u32,
                pConfirmation: ?*_DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleErrorFromOurXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Error: _DtcLu_Xln_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Error: _DtcLu_Xln_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CheckForCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                fCompareStates: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                fCompareStates: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOurTransIdSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pcbOurTransId: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pcbOurTransId: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOurCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pOurTransId: ?*u8,
                pCompareState: ?*_DtcLu_CompareState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                pOurTransId: ?*u8,
                pCompareState: ?*_DtcLu_CompareState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleTheirCompareStatesResponse: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                CompareState: _DtcLu_CompareState,
                pConfirmation: ?*_DtcLu_CompareStates_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                CompareState: _DtcLu_CompareState,
                pConfirmation: ?*_DtcLu_CompareStates_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleErrorFromOurCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Error: _DtcLu_CompareStates_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                Error: _DtcLu_CompareStates_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ConversationLost: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRecoverySeqNum: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                plRecoverySeqNum: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                plRecoverySeqNum: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ObsoleteRecoverySeqNum: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                lNewRecoverySeqNum: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcTransWork,
                lNewRecoverySeqNum: 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 IDtcLuRecoveryInitiatedByDtcTransWork_GetLogNameSizes(self: *const T, pcbOurLogName: ?*u32, pcbRemoteLogName: ?*u32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetLogNameSizes(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pcbOurLogName, pcbRemoteLogName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurXln(self: *const T, pXln: ?*_DtcLu_Xln, pOurLogName: ?*u8, pRemoteLogName: ?*u8, pdwProtocol: ?*u32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pXln, pOurLogName, pRemoteLogName, pdwProtocol);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleConfirmationFromOurXln(self: *const T, Confirmation: _DtcLu_Xln_Confirmation) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleConfirmationFromOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Confirmation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirXlnResponse(self: *const T, Xln: _DtcLu_Xln, pRemoteLogName: ?*u8, cbRemoteLogName: u32, dwProtocol: u32, pConfirmation: ?*_DtcLu_Xln_Confirmation) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleTheirXlnResponse(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Xln, pRemoteLogName, cbRemoteLogName, dwProtocol, pConfirmation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurXln(self: *const T, Error: _DtcLu_Xln_Error) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurXln(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Error);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_CheckForCompareStates(self: *const T, fCompareStates: ?*BOOL) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).CheckForCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), fCompareStates);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurTransIdSize(self: *const T, pcbOurTransId: ?*u32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurTransIdSize(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pcbOurTransId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_GetOurCompareStates(self: *const T, pOurTransId: ?*u8, pCompareState: ?*_DtcLu_CompareState) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), pOurTransId, pCompareState);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirCompareStatesResponse(self: *const T, CompareState: _DtcLu_CompareState, pConfirmation: ?*_DtcLu_CompareStates_Confirmation) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleTheirCompareStatesResponse(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), CompareState, pConfirmation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurCompareStates(self: *const T, Error: _DtcLu_CompareStates_Error) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), Error);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_ConversationLost(self: *const T) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).ConversationLost(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_GetRecoverySeqNum(self: *const T, plRecoverySeqNum: ?*i32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).GetRecoverySeqNum(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), plRecoverySeqNum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByDtcTransWork_ObsoleteRecoverySeqNum(self: *const T, lNewRecoverySeqNum: i32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcTransWork.VTable, @ptrCast(self.vtable)).ObsoleteRecoverySeqNum(@as(*const IDtcLuRecoveryInitiatedByDtcTransWork, @ptrCast(self)), lNewRecoverySeqNum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecoveryInitiatedByDtcStatusWork_Value = Guid.initString("4131e766-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRecoveryInitiatedByDtcStatusWork = &IID_IDtcLuRecoveryInitiatedByDtcStatusWork_Value;
pub const IDtcLuRecoveryInitiatedByDtcStatusWork = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        HandleCheckLuStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtcStatusWork,
                lRecoverySeqNum: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtcStatusWork,
                lRecoverySeqNum: 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 IDtcLuRecoveryInitiatedByDtcStatusWork_HandleCheckLuStatus(self: *const T, lRecoverySeqNum: i32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtcStatusWork.VTable, @ptrCast(self.vtable)).HandleCheckLuStatus(@as(*const IDtcLuRecoveryInitiatedByDtcStatusWork, @ptrCast(self)), lRecoverySeqNum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecoveryInitiatedByDtc_Value = Guid.initString("4131e764-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRecoveryInitiatedByDtc = &IID_IDtcLuRecoveryInitiatedByDtc_Value;
pub const IDtcLuRecoveryInitiatedByDtc = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetWork: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByDtc,
                pWork: ?*_DtcLu_LocalRecovery_Work,
                ppv: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByDtc,
                pWork: ?*_DtcLu_LocalRecovery_Work,
                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 IDtcLuRecoveryInitiatedByDtc_GetWork(self: *const T, pWork: ?*_DtcLu_LocalRecovery_Work, ppv: ?*?*anyopaque) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByDtc.VTable, @ptrCast(self.vtable)).GetWork(@as(*const IDtcLuRecoveryInitiatedByDtc, @ptrCast(self)), pWork, ppv);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecoveryInitiatedByLuWork_Value = Guid.initString("ac2b8ad1-d6f0-11d0-b386-00a0c9083365");
pub const IID_IDtcLuRecoveryInitiatedByLuWork = &IID_IDtcLuRecoveryInitiatedByLuWork_Value;
pub const IDtcLuRecoveryInitiatedByLuWork = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        HandleTheirXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                lRecoverySeqNum: i32,
                Xln: _DtcLu_Xln,
                pRemoteLogName: ?*u8,
                cbRemoteLogName: u32,
                pOurLogName: ?*u8,
                cbOurLogName: u32,
                dwProtocol: u32,
                pResponse: ?*_DtcLu_Xln_Response,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                lRecoverySeqNum: i32,
                Xln: _DtcLu_Xln,
                pRemoteLogName: ?*u8,
                cbRemoteLogName: u32,
                pOurLogName: ?*u8,
                cbOurLogName: u32,
                dwProtocol: u32,
                pResponse: ?*_DtcLu_Xln_Response,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOurLogNameSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pcbOurLogName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pcbOurLogName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOurXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pXln: ?*_DtcLu_Xln,
                pOurLogName: ?*u8,
                pdwProtocol: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pXln: ?*_DtcLu_Xln,
                pOurLogName: ?*u8,
                pdwProtocol: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleConfirmationOfOurXln: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Confirmation: _DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Confirmation: _DtcLu_Xln_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleTheirCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pRemoteTransId: ?*u8,
                cbRemoteTransId: u32,
                CompareState: _DtcLu_CompareState,
                pResponse: ?*_DtcLu_CompareStates_Response,
                pCompareState: ?*_DtcLu_CompareState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                pRemoteTransId: ?*u8,
                cbRemoteTransId: u32,
                CompareState: _DtcLu_CompareState,
                pResponse: ?*_DtcLu_CompareStates_Response,
                pCompareState: ?*_DtcLu_CompareState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleConfirmationOfOurCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Confirmation: _DtcLu_CompareStates_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Confirmation: _DtcLu_CompareStates_Confirmation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        HandleErrorFromOurCompareStates: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Error: _DtcLu_CompareStates_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
                Error: _DtcLu_CompareStates_Error,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ConversationLost: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLuWork,
            ) 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 IDtcLuRecoveryInitiatedByLuWork_HandleTheirXln(self: *const T, lRecoverySeqNum: i32, Xln: _DtcLu_Xln, pRemoteLogName: ?*u8, cbRemoteLogName: u32, pOurLogName: ?*u8, cbOurLogName: u32, dwProtocol: u32, pResponse: ?*_DtcLu_Xln_Response) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleTheirXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), lRecoverySeqNum, Xln, pRemoteLogName, cbRemoteLogName, pOurLogName, cbOurLogName, dwProtocol, pResponse);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_GetOurLogNameSize(self: *const T, pcbOurLogName: ?*u32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).GetOurLogNameSize(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pcbOurLogName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_GetOurXln(self: *const T, pXln: ?*_DtcLu_Xln, pOurLogName: ?*u8, pdwProtocol: ?*u32) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).GetOurXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pXln, pOurLogName, pdwProtocol);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurXln(self: *const T, Confirmation: _DtcLu_Xln_Confirmation) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleConfirmationOfOurXln(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Confirmation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_HandleTheirCompareStates(self: *const T, pRemoteTransId: ?*u8, cbRemoteTransId: u32, CompareState: _DtcLu_CompareState, pResponse: ?*_DtcLu_CompareStates_Response, pCompareState: ?*_DtcLu_CompareState) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleTheirCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), pRemoteTransId, cbRemoteTransId, CompareState, pResponse, pCompareState);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurCompareStates(self: *const T, Confirmation: _DtcLu_CompareStates_Confirmation) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleConfirmationOfOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Confirmation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_HandleErrorFromOurCompareStates(self: *const T, Error: _DtcLu_CompareStates_Error) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).HandleErrorFromOurCompareStates(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)), Error);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRecoveryInitiatedByLuWork_ConversationLost(self: *const T) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLuWork.VTable, @ptrCast(self.vtable)).ConversationLost(@as(*const IDtcLuRecoveryInitiatedByLuWork, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRecoveryInitiatedByLu_Value = Guid.initString("4131e768-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRecoveryInitiatedByLu = &IID_IDtcLuRecoveryInitiatedByLu_Value;
pub const IDtcLuRecoveryInitiatedByLu = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetObjectToHandleWorkFromLu: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRecoveryInitiatedByLu,
                ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRecoveryInitiatedByLu,
                ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork,
            ) 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 IDtcLuRecoveryInitiatedByLu_GetObjectToHandleWorkFromLu(self: *const T, ppWork: ?*?*IDtcLuRecoveryInitiatedByLuWork) HRESULT {
                return @as(*const IDtcLuRecoveryInitiatedByLu.VTable, @ptrCast(self.vtable)).GetObjectToHandleWorkFromLu(@as(*const IDtcLuRecoveryInitiatedByLu, @ptrCast(self)), ppWork);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRmEnlistment_Value = Guid.initString("4131e769-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRmEnlistment = &IID_IDtcLuRmEnlistment_Value;
pub const IDtcLuRmEnlistment = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Unplug: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
                fConversationLost: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
                fConversationLost: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackedOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Committed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Forget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistment,
            ) 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 IDtcLuRmEnlistment_Unplug(self: *const T, fConversationLost: BOOL) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Unplug(@as(*const IDtcLuRmEnlistment, @ptrCast(self)), fConversationLost);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistment_BackedOut(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistment_BackOut(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistment_Committed(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistment_Forget(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistment_RequestCommit(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistment.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuRmEnlistment, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRmEnlistmentSink_Value = Guid.initString("4131e770-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRmEnlistmentSink = &IID_IDtcLuRmEnlistmentSink_Value;
pub const IDtcLuRmEnlistmentSink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AckUnplug: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TmDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SessionLost: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackedOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Committed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Forget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Prepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentSink,
            ) 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 IDtcLuRmEnlistmentSink_AckUnplug(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).AckUnplug(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_TmDown(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).TmDown(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_SessionLost(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).SessionLost(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_BackedOut(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_BackOut(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_Committed(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_Forget(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_Prepare(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).Prepare(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuRmEnlistmentSink_RequestCommit(self: *const T) HRESULT {
                return @as(*const IDtcLuRmEnlistmentSink.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuRmEnlistmentSink, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuRmEnlistmentFactory_Value = Guid.initString("4131e771-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuRmEnlistmentFactory = &IID_IDtcLuRmEnlistmentFactory_Value;
pub const IDtcLuRmEnlistmentFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuRmEnlistmentFactory,
                pucLuPair: ?*u8,
                cbLuPair: u32,
                pITransaction: ?*ITransaction,
                pTransId: ?*u8,
                cbTransId: u32,
                pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink,
                ppRmEnlistment: ?*?*IDtcLuRmEnlistment,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuRmEnlistmentFactory,
                pucLuPair: ?*u8,
                cbLuPair: u32,
                pITransaction: ?*ITransaction,
                pTransId: ?*u8,
                cbTransId: u32,
                pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink,
                ppRmEnlistment: ?*?*IDtcLuRmEnlistment,
            ) 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 IDtcLuRmEnlistmentFactory_Create(self: *const T, pucLuPair: ?*u8, cbLuPair: u32, pITransaction: ?*ITransaction, pTransId: ?*u8, cbTransId: u32, pRmEnlistmentSink: ?*IDtcLuRmEnlistmentSink, ppRmEnlistment: ?*?*IDtcLuRmEnlistment) HRESULT {
                return @as(*const IDtcLuRmEnlistmentFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuRmEnlistmentFactory, @ptrCast(self)), pucLuPair, cbLuPair, pITransaction, pTransId, cbTransId, pRmEnlistmentSink, ppRmEnlistment);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuSubordinateDtc_Value = Guid.initString("4131e773-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuSubordinateDtc = &IID_IDtcLuSubordinateDtc_Value;
pub const IDtcLuSubordinateDtc = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Unplug: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
                fConversationLost: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
                fConversationLost: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackedOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Committed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Forget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Prepare: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtc,
            ) 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 IDtcLuSubordinateDtc_Unplug(self: *const T, fConversationLost: BOOL) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Unplug(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)), fConversationLost);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_BackedOut(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_BackOut(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_Committed(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_Forget(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_Prepare(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).Prepare(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtc_RequestCommit(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtc.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuSubordinateDtc, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuSubordinateDtcSink_Value = Guid.initString("4131e774-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuSubordinateDtcSink = &IID_IDtcLuSubordinateDtcSink_Value;
pub const IDtcLuSubordinateDtcSink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AckUnplug: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TmDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SessionLost: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackedOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BackOut: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Committed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Forget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestCommit: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcSink,
            ) 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 IDtcLuSubordinateDtcSink_AckUnplug(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).AckUnplug(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_TmDown(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).TmDown(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_SessionLost(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).SessionLost(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_BackedOut(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).BackedOut(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_BackOut(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).BackOut(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_Committed(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).Committed(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_Forget(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).Forget(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDtcLuSubordinateDtcSink_RequestCommit(self: *const T) HRESULT {
                return @as(*const IDtcLuSubordinateDtcSink.VTable, @ptrCast(self.vtable)).RequestCommit(@as(*const IDtcLuSubordinateDtcSink, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDtcLuSubordinateDtcFactory_Value = Guid.initString("4131e775-1aea-11d0-944b-00a0c905416e");
pub const IID_IDtcLuSubordinateDtcFactory = &IID_IDtcLuSubordinateDtcFactory_Value;
pub const IDtcLuSubordinateDtcFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDtcLuSubordinateDtcFactory,
                pucLuPair: ?*u8,
                cbLuPair: u32,
                punkTransactionOuter: ?*IUnknown,
                isoLevel: i32,
                isoFlags: u32,
                pOptions: ?*ITransactionOptions,
                ppTransaction: ?*?*ITransaction,
                pTransId: ?*u8,
                cbTransId: u32,
                pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink,
                ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDtcLuSubordinateDtcFactory,
                pucLuPair: ?*u8,
                cbLuPair: u32,
                punkTransactionOuter: ?*IUnknown,
                isoLevel: i32,
                isoFlags: u32,
                pOptions: ?*ITransactionOptions,
                ppTransaction: ?*?*ITransaction,
                pTransId: ?*u8,
                cbTransId: u32,
                pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink,
                ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc,
            ) 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 IDtcLuSubordinateDtcFactory_Create(self: *const T, pucLuPair: ?*u8, cbLuPair: u32, punkTransactionOuter: ?*IUnknown, isoLevel: i32, isoFlags: u32, pOptions: ?*ITransactionOptions, ppTransaction: ?*?*ITransaction, pTransId: ?*u8, cbTransId: u32, pSubordinateDtcSink: ?*IDtcLuSubordinateDtcSink, ppSubordinateDtc: ?*?*IDtcLuSubordinateDtc) HRESULT {
                return @as(*const IDtcLuSubordinateDtcFactory.VTable, @ptrCast(self.vtable)).Create(@as(*const IDtcLuSubordinateDtcFactory, @ptrCast(self)), pucLuPair, cbLuPair, punkTransactionOuter, isoLevel, isoFlags, pOptions, ppTransaction, pTransId, cbTransId, pSubordinateDtcSink, ppSubordinateDtc);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (4)
//--------------------------------------------------------------------------------
pub extern "xolehlp" fn DtcGetTransactionManager(
    i_pszHost: ?PSTR,
    i_pszTmName: ?PSTR,
    i_riid: ?*const Guid,
    i_dwReserved1: u32,
    i_wcbReserved2: u16,
    // TODO: what to do with BytesParamIndex 4?
    i_pvReserved2: ?*anyopaque,
    o_ppvObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xolehlp" fn DtcGetTransactionManagerC(
    i_pszHost: ?PSTR,
    i_pszTmName: ?PSTR,
    i_riid: ?*const Guid,
    i_dwReserved1: u32,
    i_wcbReserved2: u16,
    // TODO: what to do with BytesParamIndex 4?
    i_pvReserved2: ?*anyopaque,
    o_ppvObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xolehlp" fn DtcGetTransactionManagerExA(
    i_pszHost: ?PSTR,
    i_pszTmName: ?PSTR,
    i_riid: ?*const Guid,
    i_grfOptions: u32,
    i_pvConfigParams: ?*anyopaque,
    o_ppvObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xolehlp" fn DtcGetTransactionManagerExW(
    i_pwszHost: ?PWSTR,
    i_pwszTmName: ?PWSTR,
    i_riid: ?*const Guid,
    i_grfOptions: u32,
    i_pvConfigParams: ?*anyopaque,
    o_ppvObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (2)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {
        pub const DTC_GET_TRANSACTION_MANAGER_EX_ = thismodule.DTC_GET_TRANSACTION_MANAGER_EX_A;
        pub const DtcGetTransactionManagerEx = thismodule.DtcGetTransactionManagerExA;
    },
    .wide => struct {
        pub const DTC_GET_TRANSACTION_MANAGER_EX_ = thismodule.DTC_GET_TRANSACTION_MANAGER_EX_W;
        pub const DtcGetTransactionManagerEx = thismodule.DtcGetTransactionManagerExW;
    },
    .unspecified => if (@import("builtin").is_test) struct {
        pub const DTC_GET_TRANSACTION_MANAGER_EX_ = *opaque {};
        pub const DtcGetTransactionManagerEx = *opaque {};
    } else struct {
        pub const DTC_GET_TRANSACTION_MANAGER_EX_ = @compileError("'DTC_GET_TRANSACTION_MANAGER_EX_' requires that UNICODE be set to true or false in the root module");
        pub const DtcGetTransactionManagerEx = @compileError("'DtcGetTransactionManagerEx' requires that UNICODE be set to true or false in the root module");
    },
};
//--------------------------------------------------------------------------------
// Section: Imports (10)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const CHAR = @import("../foundation.zig").CHAR;
const FILETIME = @import("../foundation.zig").FILETIME;
const HANDLE = @import("../foundation.zig").HANDLE;
const HRESULT = @import("../foundation.zig").HRESULT;
const IMoniker = @import("../system/com.zig").IMoniker;
const IUnknown = @import("../system/com.zig").IUnknown;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;

test {
    // The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
    if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER")) {
        _ = DTC_GET_TRANSACTION_MANAGER;
    }
    if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER_EX_A")) {
        _ = DTC_GET_TRANSACTION_MANAGER_EX_A;
    }
    if (@hasDecl(@This(), "DTC_GET_TRANSACTION_MANAGER_EX_W")) {
        _ = DTC_GET_TRANSACTION_MANAGER_EX_W;
    }
    if (@hasDecl(@This(), "DTC_INSTALL_CLIENT")) {
        _ = DTC_INSTALL_CLIENT;
    }
    if (@hasDecl(@This(), "XA_OPEN_EPT")) {
        _ = XA_OPEN_EPT;
    }
    if (@hasDecl(@This(), "XA_CLOSE_EPT")) {
        _ = XA_CLOSE_EPT;
    }
    if (@hasDecl(@This(), "XA_START_EPT")) {
        _ = XA_START_EPT;
    }
    if (@hasDecl(@This(), "XA_END_EPT")) {
        _ = XA_END_EPT;
    }
    if (@hasDecl(@This(), "XA_ROLLBACK_EPT")) {
        _ = XA_ROLLBACK_EPT;
    }
    if (@hasDecl(@This(), "XA_PREPARE_EPT")) {
        _ = XA_PREPARE_EPT;
    }
    if (@hasDecl(@This(), "XA_COMMIT_EPT")) {
        _ = XA_COMMIT_EPT;
    }
    if (@hasDecl(@This(), "XA_RECOVER_EPT")) {
        _ = XA_RECOVER_EPT;
    }
    if (@hasDecl(@This(), "XA_FORGET_EPT")) {
        _ = XA_FORGET_EPT;
    }
    if (@hasDecl(@This(), "XA_COMPLETE_EPT")) {
        _ = XA_COMPLETE_EPT;
    }

    @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);
        }
    }
}
