//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (124)
//--------------------------------------------------------------------------------
pub const DISPID_RDPSRAPI_METHOD_OPEN = @as(u32, 100);
pub const DISPID_RDPSRAPI_METHOD_CLOSE = @as(u32, 101);
pub const DISPID_RDPSRAPI_METHOD_SETSHAREDRECT = @as(u32, 102);
pub const DISPID_RDPSRAPI_METHOD_GETSHAREDRECT = @as(u32, 103);
pub const DISPID_RDPSRAPI_METHOD_VIEWERCONNECT = @as(u32, 104);
pub const DISPID_RDPSRAPI_METHOD_VIEWERDISCONNECT = @as(u32, 105);
pub const DISPID_RDPSRAPI_METHOD_TERMINATE_CONNECTION = @as(u32, 106);
pub const DISPID_RDPSRAPI_METHOD_CREATE_INVITATION = @as(u32, 107);
pub const DISPID_RDPSRAPI_METHOD_REQUEST_CONTROL = @as(u32, 108);
pub const DISPID_RDPSRAPI_METHOD_VIRTUAL_CHANNEL_CREATE = @as(u32, 109);
pub const DISPID_RDPSRAPI_METHOD_VIRTUAL_CHANNEL_SEND_DATA = @as(u32, 110);
pub const DISPID_RDPSRAPI_METHOD_VIRTUAL_CHANNEL_SET_ACCESS = @as(u32, 111);
pub const DISPID_RDPSRAPI_METHOD_PAUSE = @as(u32, 112);
pub const DISPID_RDPSRAPI_METHOD_RESUME = @as(u32, 113);
pub const DISPID_RDPSRAPI_METHOD_SHOW_WINDOW = @as(u32, 114);
pub const DISPID_RDPSRAPI_METHOD_REQUEST_COLOR_DEPTH_CHANGE = @as(u32, 115);
pub const DISPID_RDPSRAPI_METHOD_STARTREVCONNECTLISTENER = @as(u32, 116);
pub const DISPID_RDPSRAPI_METHOD_CONNECTTOCLIENT = @as(u32, 117);
pub const DISPID_RDPSRAPI_METHOD_SET_RENDERING_SURFACE = @as(u32, 118);
pub const DISPID_RDPSRAPI_METHOD_SEND_MOUSE_BUTTON_EVENT = @as(u32, 119);
pub const DISPID_RDPSRAPI_METHOD_SEND_MOUSE_MOVE_EVENT = @as(u32, 120);
pub const DISPID_RDPSRAPI_METHOD_SEND_MOUSE_WHEEL_EVENT = @as(u32, 121);
pub const DISPID_RDPSRAPI_METHOD_SEND_KEYBOARD_EVENT = @as(u32, 122);
pub const DISPID_RDPSRAPI_METHOD_SEND_SYNC_EVENT = @as(u32, 123);
pub const DISPID_RDPSRAPI_METHOD_BEGIN_TOUCH_FRAME = @as(u32, 124);
pub const DISPID_RDPSRAPI_METHOD_ADD_TOUCH_INPUT = @as(u32, 125);
pub const DISPID_RDPSRAPI_METHOD_END_TOUCH_FRAME = @as(u32, 126);
pub const DISPID_RDPSRAPI_METHOD_CONNECTUSINGTRANSPORTSTREAM = @as(u32, 127);
pub const DISPID_RDPSRAPI_METHOD_SENDCONTROLLEVELCHANGERESPONSE = @as(u32, 148);
pub const DISPID_RDPSRAPI_METHOD_GETFRAMEBUFFERBITS = @as(u32, 149);
pub const DISPID_RDPSRAPI_PROP_DISPIDVALUE = @as(u32, 200);
pub const DISPID_RDPSRAPI_PROP_ID = @as(u32, 201);
pub const DISPID_RDPSRAPI_PROP_SESSION_PROPERTIES = @as(u32, 202);
pub const DISPID_RDPSRAPI_PROP_ATTENDEES = @as(u32, 203);
pub const DISPID_RDPSRAPI_PROP_INVITATIONS = @as(u32, 204);
pub const DISPID_RDPSRAPI_PROP_INVITATION = @as(u32, 205);
pub const DISPID_RDPSRAPI_PROP_CHANNELMANAGER = @as(u32, 206);
pub const DISPID_RDPSRAPI_PROP_VIRTUAL_CHANNEL_GETNAME = @as(u32, 207);
pub const DISPID_RDPSRAPI_PROP_VIRTUAL_CHANNEL_GETFLAGS = @as(u32, 208);
pub const DISPID_RDPSRAPI_PROP_VIRTUAL_CHANNEL_GETPRIORITY = @as(u32, 209);
pub const DISPID_RDPSRAPI_PROP_WINDOWID = @as(u32, 210);
pub const DISPID_RDPSRAPI_PROP_APPLICATION = @as(u32, 211);
pub const DISPID_RDPSRAPI_PROP_WINDOWSHARED = @as(u32, 212);
pub const DISPID_RDPSRAPI_PROP_WINDOWNAME = @as(u32, 213);
pub const DISPID_RDPSRAPI_PROP_APPNAME = @as(u32, 214);
pub const DISPID_RDPSRAPI_PROP_APPLICATION_FILTER = @as(u32, 215);
pub const DISPID_RDPSRAPI_PROP_WINDOW_LIST = @as(u32, 216);
pub const DISPID_RDPSRAPI_PROP_APPLICATION_LIST = @as(u32, 217);
pub const DISPID_RDPSRAPI_PROP_APPFILTER_ENABLED = @as(u32, 218);
pub const DISPID_RDPSRAPI_PROP_APPFILTERENABLED = @as(u32, 219);
pub const DISPID_RDPSRAPI_PROP_SHARED = @as(u32, 220);
pub const DISPID_RDPSRAPI_PROP_INVITATIONITEM = @as(u32, 221);
pub const DISPID_RDPSRAPI_PROP_DBG_CLX_CMDLINE = @as(u32, 222);
pub const DISPID_RDPSRAPI_PROP_APPFLAGS = @as(u32, 223);
pub const DISPID_RDPSRAPI_PROP_WNDFLAGS = @as(u32, 224);
pub const DISPID_RDPSRAPI_PROP_PROTOCOL_TYPE = @as(u32, 225);
pub const DISPID_RDPSRAPI_PROP_LOCAL_PORT = @as(u32, 226);
pub const DISPID_RDPSRAPI_PROP_LOCAL_IP = @as(u32, 227);
pub const DISPID_RDPSRAPI_PROP_PEER_PORT = @as(u32, 228);
pub const DISPID_RDPSRAPI_PROP_PEER_IP = @as(u32, 229);
pub const DISPID_RDPSRAPI_PROP_ATTENDEE_FLAGS = @as(u32, 230);
pub const DISPID_RDPSRAPI_PROP_CONINFO = @as(u32, 231);
pub const DISPID_RDPSRAPI_PROP_CONNECTION_STRING = @as(u32, 232);
pub const DISPID_RDPSRAPI_PROP_GROUP_NAME = @as(u32, 233);
pub const DISPID_RDPSRAPI_PROP_PASSWORD = @as(u32, 234);
pub const DISPID_RDPSRAPI_PROP_ATTENDEELIMIT = @as(u32, 235);
pub const DISPID_RDPSRAPI_PROP_REVOKED = @as(u32, 236);
pub const DISPID_RDPSRAPI_PROP_DISCONNECTED_STRING = @as(u32, 237);
pub const DISPID_RDPSRAPI_PROP_USESMARTSIZING = @as(u32, 238);
pub const DISPID_RDPSRAPI_PROP_SESSION_COLORDEPTH = @as(u32, 239);
pub const DISPID_RDPSRAPI_PROP_REASON = @as(u32, 240);
pub const DISPID_RDPSRAPI_PROP_CODE = @as(u32, 241);
pub const DISPID_RDPSRAPI_PROP_CTRL_LEVEL = @as(u32, 242);
pub const DISPID_RDPSRAPI_PROP_REMOTENAME = @as(u32, 243);
pub const DISPID_RDPSRAPI_PROP_COUNT = @as(u32, 244);
pub const DISPID_RDPSRAPI_PROP_FRAMEBUFFER_HEIGHT = @as(u32, 251);
pub const DISPID_RDPSRAPI_PROP_FRAMEBUFFER_WIDTH = @as(u32, 252);
pub const DISPID_RDPSRAPI_PROP_FRAMEBUFFER_BPP = @as(u32, 253);
pub const DISPID_RDPSRAPI_PROP_FRAMEBUFFER = @as(u32, 254);
pub const DISPID_RDPSRAPI_EVENT_ON_ATTENDEE_CONNECTED = @as(u32, 301);
pub const DISPID_RDPSRAPI_EVENT_ON_ATTENDEE_DISCONNECTED = @as(u32, 302);
pub const DISPID_RDPSRAPI_EVENT_ON_ATTENDEE_UPDATE = @as(u32, 303);
pub const DISPID_RDPSRAPI_EVENT_ON_ERROR = @as(u32, 304);
pub const DISPID_RDPSRAPI_EVENT_ON_VIEWER_CONNECTED = @as(u32, 305);
pub const DISPID_RDPSRAPI_EVENT_ON_VIEWER_DISCONNECTED = @as(u32, 306);
pub const DISPID_RDPSRAPI_EVENT_ON_VIEWER_AUTHENTICATED = @as(u32, 307);
pub const DISPID_RDPSRAPI_EVENT_ON_VIEWER_CONNECTFAILED = @as(u32, 308);
pub const DISPID_RDPSRAPI_EVENT_ON_CTRLLEVEL_CHANGE_REQUEST = @as(u32, 309);
pub const DISPID_RDPSRAPI_EVENT_ON_GRAPHICS_STREAM_PAUSED = @as(u32, 310);
pub const DISPID_RDPSRAPI_EVENT_ON_GRAPHICS_STREAM_RESUMED = @as(u32, 311);
pub const DISPID_RDPSRAPI_EVENT_ON_VIRTUAL_CHANNEL_JOIN = @as(u32, 312);
pub const DISPID_RDPSRAPI_EVENT_ON_VIRTUAL_CHANNEL_LEAVE = @as(u32, 313);
pub const DISPID_RDPSRAPI_EVENT_ON_VIRTUAL_CHANNEL_DATARECEIVED = @as(u32, 314);
pub const DISPID_RDPSRAPI_EVENT_ON_VIRTUAL_CHANNEL_SENDCOMPLETED = @as(u32, 315);
pub const DISPID_RDPSRAPI_EVENT_ON_APPLICATION_OPEN = @as(u32, 316);
pub const DISPID_RDPSRAPI_EVENT_ON_APPLICATION_CLOSE = @as(u32, 317);
pub const DISPID_RDPSRAPI_EVENT_ON_APPLICATION_UPDATE = @as(u32, 318);
pub const DISPID_RDPSRAPI_EVENT_ON_WINDOW_OPEN = @as(u32, 319);
pub const DISPID_RDPSRAPI_EVENT_ON_WINDOW_CLOSE = @as(u32, 320);
pub const DISPID_RDPSRAPI_EVENT_ON_WINDOW_UPDATE = @as(u32, 321);
pub const DISPID_RDPSRAPI_EVENT_ON_APPFILTER_UPDATE = @as(u32, 322);
pub const DISPID_RDPSRAPI_EVENT_ON_SHARED_RECT_CHANGED = @as(u32, 323);
pub const DISPID_RDPSRAPI_EVENT_ON_FOCUSRELEASED = @as(u32, 324);
pub const DISPID_RDPSRAPI_EVENT_ON_SHARED_DESKTOP_SETTINGS_CHANGED = @as(u32, 325);
pub const DISPID_RDPSRAPI_EVENT_ON_CTRLLEVEL_CHANGE_RESPONSE = @as(u32, 338);
pub const DISPID_RDPAPI_EVENT_ON_BOUNDING_RECT_CHANGED = @as(u32, 340);
pub const DISPID_RDPSRAPI_METHOD_STREAM_ALLOCBUFFER = @as(u32, 421);
pub const DISPID_RDPSRAPI_METHOD_STREAM_FREEBUFFER = @as(u32, 422);
pub const DISPID_RDPSRAPI_METHOD_STREAMSENDDATA = @as(u32, 423);
pub const DISPID_RDPSRAPI_METHOD_STREAMREADDATA = @as(u32, 424);
pub const DISPID_RDPSRAPI_METHOD_STREAMOPEN = @as(u32, 425);
pub const DISPID_RDPSRAPI_METHOD_STREAMCLOSE = @as(u32, 426);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_STORAGE = @as(u32, 555);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_PAYLOADSIZE = @as(u32, 558);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_PAYLOADOFFSET = @as(u32, 559);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_CONTEXT = @as(u32, 560);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_FLAGS = @as(u32, 561);
pub const DISPID_RDPSRAPI_PROP_STREAMBUFFER_STORESIZE = @as(u32, 562);
pub const DISPID_RDPSRAPI_EVENT_ON_STREAM_SENDCOMPLETED = @as(u32, 632);
pub const DISPID_RDPSRAPI_EVENT_ON_STREAM_DATARECEIVED = @as(u32, 633);
pub const DISPID_RDPSRAPI_EVENT_ON_STREAM_CLOSED = @as(u32, 634);
pub const DISPID_RDPSRAPI_EVENT_VIEW_MOUSE_BUTTON_RECEIVED = @as(u32, 700);
pub const DISPID_RDPSRAPI_EVENT_VIEW_MOUSE_MOVE_RECEIVED = @as(u32, 701);
pub const DISPID_RDPSRAPI_EVENT_VIEW_MOUSE_WHEEL_RECEIVED = @as(u32, 702);

//--------------------------------------------------------------------------------
// Section: Types (58)
//--------------------------------------------------------------------------------
const CLSID_RDPViewer_Value = Guid.initString("32be5ed2-5c86-480f-a914-0ff8885a1b3f");
pub const CLSID_RDPViewer = &CLSID_RDPViewer_Value;

const CLSID_RDPSRAPISessionProperties_Value = Guid.initString("dd7594ff-ea2a-4c06-8fdf-132de48b6510");
pub const CLSID_RDPSRAPISessionProperties = &CLSID_RDPSRAPISessionProperties_Value;

const CLSID_RDPSRAPIInvitationManager_Value = Guid.initString("53d9c9db-75ab-4271-948a-4c4eb36a8f2b");
pub const CLSID_RDPSRAPIInvitationManager = &CLSID_RDPSRAPIInvitationManager_Value;

const CLSID_RDPSRAPIInvitation_Value = Guid.initString("49174dc6-0731-4b5e-8ee1-83a63d3868fa");
pub const CLSID_RDPSRAPIInvitation = &CLSID_RDPSRAPIInvitation_Value;

const CLSID_RDPSRAPIAttendeeManager_Value = Guid.initString("d7b13a01-f7d4-42a6-8595-12fc8c24e851");
pub const CLSID_RDPSRAPIAttendeeManager = &CLSID_RDPSRAPIAttendeeManager_Value;

const CLSID_RDPSRAPIAttendee_Value = Guid.initString("74f93bb5-755f-488e-8a29-2390108aef55");
pub const CLSID_RDPSRAPIAttendee = &CLSID_RDPSRAPIAttendee_Value;

const CLSID_RDPSRAPIAttendeeDisconnectInfo_Value = Guid.initString("b47d7250-5bdb-405d-b487-caad9c56f4f8");
pub const CLSID_RDPSRAPIAttendeeDisconnectInfo = &CLSID_RDPSRAPIAttendeeDisconnectInfo_Value;

const CLSID_RDPSRAPIApplicationFilter_Value = Guid.initString("e35ace89-c7e8-427e-a4f9-b9da072826bd");
pub const CLSID_RDPSRAPIApplicationFilter = &CLSID_RDPSRAPIApplicationFilter_Value;

const CLSID_RDPSRAPIApplicationList_Value = Guid.initString("9e31c815-7433-4876-97fb-ed59fe2baa22");
pub const CLSID_RDPSRAPIApplicationList = &CLSID_RDPSRAPIApplicationList_Value;

const CLSID_RDPSRAPIApplication_Value = Guid.initString("c116a484-4b25-4b9f-8a54-b934b06e57fa");
pub const CLSID_RDPSRAPIApplication = &CLSID_RDPSRAPIApplication_Value;

const CLSID_RDPSRAPIWindowList_Value = Guid.initString("9c21e2b8-5dd4-42cc-81ba-1c099852e6fa");
pub const CLSID_RDPSRAPIWindowList = &CLSID_RDPSRAPIWindowList_Value;

const CLSID_RDPSRAPIWindow_Value = Guid.initString("03cf46db-ce45-4d36-86ed-ed28b74398bf");
pub const CLSID_RDPSRAPIWindow = &CLSID_RDPSRAPIWindow_Value;

const CLSID_RDPSRAPITcpConnectionInfo_Value = Guid.initString("be49db3f-ebb6-4278-8ce0-d5455833eaee");
pub const CLSID_RDPSRAPITcpConnectionInfo = &CLSID_RDPSRAPITcpConnectionInfo_Value;

const CLSID_RDPSession_Value = Guid.initString("9b78f0e6-3e05-4a5b-b2e8-e743a8956b65");
pub const CLSID_RDPSession = &CLSID_RDPSession_Value;

const CLSID_RDPSRAPIFrameBuffer_Value = Guid.initString("a4f66bcc-538e-4101-951d-30847adb5101");
pub const CLSID_RDPSRAPIFrameBuffer = &CLSID_RDPSRAPIFrameBuffer_Value;

const CLSID_RDPTransportStreamBuffer_Value = Guid.initString("8d4a1c69-f17f-4549-a699-761c6e6b5c0a");
pub const CLSID_RDPTransportStreamBuffer = &CLSID_RDPTransportStreamBuffer_Value;

const CLSID_RDPTransportStreamEvents_Value = Guid.initString("31e3ab20-5350-483f-9dc6-6748665efdeb");
pub const CLSID_RDPTransportStreamEvents = &CLSID_RDPTransportStreamEvents_Value;

pub const CTRL_LEVEL = enum(i32) {
    MIN = 0,
    // INVALID = 0, this enum value conflicts with MIN
    NONE = 1,
    VIEW = 2,
    INTERACTIVE = 3,
    REQCTRL_VIEW = 4,
    REQCTRL_INTERACTIVE = 5,
    // MAX = 5, this enum value conflicts with REQCTRL_INTERACTIVE
};
pub const CTRL_LEVEL_MIN = CTRL_LEVEL.MIN;
pub const CTRL_LEVEL_INVALID = CTRL_LEVEL.MIN;
pub const CTRL_LEVEL_NONE = CTRL_LEVEL.NONE;
pub const CTRL_LEVEL_VIEW = CTRL_LEVEL.VIEW;
pub const CTRL_LEVEL_INTERACTIVE = CTRL_LEVEL.INTERACTIVE;
pub const CTRL_LEVEL_REQCTRL_VIEW = CTRL_LEVEL.REQCTRL_VIEW;
pub const CTRL_LEVEL_REQCTRL_INTERACTIVE = CTRL_LEVEL.REQCTRL_INTERACTIVE;
pub const CTRL_LEVEL_MAX = CTRL_LEVEL.REQCTRL_INTERACTIVE;

pub const ATTENDEE_DISCONNECT_REASON = enum(i32) {
    MIN = 0,
    // APP = 0, this enum value conflicts with MIN
    ERR = 1,
    CLI = 2,
    // MAX = 2, this enum value conflicts with CLI
};
pub const ATTENDEE_DISCONNECT_REASON_MIN = ATTENDEE_DISCONNECT_REASON.MIN;
pub const ATTENDEE_DISCONNECT_REASON_APP = ATTENDEE_DISCONNECT_REASON.MIN;
pub const ATTENDEE_DISCONNECT_REASON_ERR = ATTENDEE_DISCONNECT_REASON.ERR;
pub const ATTENDEE_DISCONNECT_REASON_CLI = ATTENDEE_DISCONNECT_REASON.CLI;
pub const ATTENDEE_DISCONNECT_REASON_MAX = ATTENDEE_DISCONNECT_REASON.CLI;

pub const CHANNEL_PRIORITY = enum(i32) {
    LO = 0,
    MED = 1,
    HI = 2,
};
pub const CHANNEL_PRIORITY_LO = CHANNEL_PRIORITY.LO;
pub const CHANNEL_PRIORITY_MED = CHANNEL_PRIORITY.MED;
pub const CHANNEL_PRIORITY_HI = CHANNEL_PRIORITY.HI;

pub const CHANNEL_FLAGS = enum(i32) {
    LEGACY = 1,
    UNCOMPRESSED = 2,
    DYNAMIC = 4,
};
pub const CHANNEL_FLAGS_LEGACY = CHANNEL_FLAGS.LEGACY;
pub const CHANNEL_FLAGS_UNCOMPRESSED = CHANNEL_FLAGS.UNCOMPRESSED;
pub const CHANNEL_FLAGS_DYNAMIC = CHANNEL_FLAGS.DYNAMIC;

pub const CHANNEL_ACCESS_ENUM = enum(i32) {
    NONE = 0,
    SENDRECEIVE = 1,
};
pub const CHANNEL_ACCESS_ENUM_NONE = CHANNEL_ACCESS_ENUM.NONE;
pub const CHANNEL_ACCESS_ENUM_SENDRECEIVE = CHANNEL_ACCESS_ENUM.SENDRECEIVE;

pub const RDPENCOMAPI_ATTENDEE_FLAGS = enum(i32) {
    L = 1,
};
pub const ATTENDEE_FLAGS_LOCAL = RDPENCOMAPI_ATTENDEE_FLAGS.L;

pub const RDPSRAPI_WND_FLAGS = enum(i32) {
    D = 1,
};
pub const WND_FLAG_PRIVILEGED = RDPSRAPI_WND_FLAGS.D;

pub const RDPSRAPI_APP_FLAGS = enum(i32) {
    D = 1,
};
pub const APP_FLAG_PRIVILEGED = RDPSRAPI_APP_FLAGS.D;

pub const RDPSRAPI_MOUSE_BUTTON_TYPE = enum(i32) {
    BUTTON1 = 0,
    BUTTON2 = 1,
    BUTTON3 = 2,
    XBUTTON1 = 3,
    XBUTTON2 = 4,
    XBUTTON3 = 5,
};
pub const RDPSRAPI_MOUSE_BUTTON_BUTTON1 = RDPSRAPI_MOUSE_BUTTON_TYPE.BUTTON1;
pub const RDPSRAPI_MOUSE_BUTTON_BUTTON2 = RDPSRAPI_MOUSE_BUTTON_TYPE.BUTTON2;
pub const RDPSRAPI_MOUSE_BUTTON_BUTTON3 = RDPSRAPI_MOUSE_BUTTON_TYPE.BUTTON3;
pub const RDPSRAPI_MOUSE_BUTTON_XBUTTON1 = RDPSRAPI_MOUSE_BUTTON_TYPE.XBUTTON1;
pub const RDPSRAPI_MOUSE_BUTTON_XBUTTON2 = RDPSRAPI_MOUSE_BUTTON_TYPE.XBUTTON2;
pub const RDPSRAPI_MOUSE_BUTTON_XBUTTON3 = RDPSRAPI_MOUSE_BUTTON_TYPE.XBUTTON3;

pub const RDPSRAPI_KBD_CODE_TYPE = enum(i32) {
    SCANCODE = 0,
    UNICODE = 1,
};
pub const RDPSRAPI_KBD_CODE_SCANCODE = RDPSRAPI_KBD_CODE_TYPE.SCANCODE;
pub const RDPSRAPI_KBD_CODE_UNICODE = RDPSRAPI_KBD_CODE_TYPE.UNICODE;

pub const RDPSRAPI_KBD_SYNC_FLAG = enum(i32) {
    SCROLL_LOCK = 1,
    NUM_LOCK = 2,
    CAPS_LOCK = 4,
    KANA_LOCK = 8,
};
pub const RDPSRAPI_KBD_SYNC_FLAG_SCROLL_LOCK = RDPSRAPI_KBD_SYNC_FLAG.SCROLL_LOCK;
pub const RDPSRAPI_KBD_SYNC_FLAG_NUM_LOCK = RDPSRAPI_KBD_SYNC_FLAG.NUM_LOCK;
pub const RDPSRAPI_KBD_SYNC_FLAG_CAPS_LOCK = RDPSRAPI_KBD_SYNC_FLAG.CAPS_LOCK;
pub const RDPSRAPI_KBD_SYNC_FLAG_KANA_LOCK = RDPSRAPI_KBD_SYNC_FLAG.KANA_LOCK;

const IID_IRDPSRAPIDebug_Value = Guid.initString("aa1e42b5-496d-4ca4-a690-348dcb2ec4ad");
pub const IID_IRDPSRAPIDebug = &IID_IRDPSRAPIDebug_Value;
pub const IRDPSRAPIDebug = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_CLXCmdLine: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIDebug,
                CLXCmdLine: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIDebug,
                CLXCmdLine: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CLXCmdLine: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIDebug,
                pCLXCmdLine: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIDebug,
                pCLXCmdLine: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIDebug_put_CLXCmdLine(self: *const T, CLXCmdLine: ?BSTR) HRESULT {
                return @as(*const IRDPSRAPIDebug.VTable, @ptrCast(self.vtable)).put_CLXCmdLine(@as(*const IRDPSRAPIDebug, @ptrCast(self)), CLXCmdLine);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIDebug_get_CLXCmdLine(self: *const T, pCLXCmdLine: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIDebug.VTable, @ptrCast(self.vtable)).get_CLXCmdLine(@as(*const IRDPSRAPIDebug, @ptrCast(self)), pCLXCmdLine);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.1'
const IID_IRDPSRAPIPerfCounterLogger_Value = Guid.initString("071c2533-0fa4-4e8f-ae83-9c10b4305ab5");
pub const IID_IRDPSRAPIPerfCounterLogger = &IID_IRDPSRAPIPerfCounterLogger_Value;
pub const IRDPSRAPIPerfCounterLogger = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        LogValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIPerfCounterLogger,
                lValue: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIPerfCounterLogger,
                lValue: i64,
            ) 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 IRDPSRAPIPerfCounterLogger_LogValue(self: *const T, lValue: i64) HRESULT {
                return @as(*const IRDPSRAPIPerfCounterLogger.VTable, @ptrCast(self.vtable)).LogValue(@as(*const IRDPSRAPIPerfCounterLogger, @ptrCast(self)), lValue);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.1'
const IID_IRDPSRAPIPerfCounterLoggingManager_Value = Guid.initString("9a512c86-ac6e-4a8e-b1a4-fcef363f6e64");
pub const IID_IRDPSRAPIPerfCounterLoggingManager = &IID_IRDPSRAPIPerfCounterLoggingManager_Value;
pub const IRDPSRAPIPerfCounterLoggingManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateLogger: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIPerfCounterLoggingManager,
                bstrCounterName: ?BSTR,
                ppLogger: ?*?*IRDPSRAPIPerfCounterLogger,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIPerfCounterLoggingManager,
                bstrCounterName: ?BSTR,
                ppLogger: ?*?*IRDPSRAPIPerfCounterLogger,
            ) 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 IRDPSRAPIPerfCounterLoggingManager_CreateLogger(self: *const T, bstrCounterName: ?BSTR, ppLogger: ?*?*IRDPSRAPIPerfCounterLogger) HRESULT {
                return @as(*const IRDPSRAPIPerfCounterLoggingManager.VTable, @ptrCast(self.vtable)).CreateLogger(@as(*const IRDPSRAPIPerfCounterLoggingManager, @ptrCast(self)), bstrCounterName, ppLogger);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.1'
const IID_IRDPSRAPIAudioStream_Value = Guid.initString("e3e30ef9-89c6-4541-ba3b-19336ac6d31c");
pub const IID_IRDPSRAPIAudioStream = &IID_IRDPSRAPIAudioStream_Value;
pub const IRDPSRAPIAudioStream = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAudioStream,
                pnPeriodInHundredNsIntervals: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAudioStream,
                pnPeriodInHundredNsIntervals: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Start: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAudioStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAudioStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Stop: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAudioStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAudioStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAudioStream,
                ppbData: [*]?*u8,
                pcbData: ?*u32,
                pTimestamp: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAudioStream,
                ppbData: [*]?*u8,
                pcbData: ?*u32,
                pTimestamp: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FreeBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAudioStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAudioStream,
            ) 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 IRDPSRAPIAudioStream_Initialize(self: *const T, pnPeriodInHundredNsIntervals: ?*i64) HRESULT {
                return @as(*const IRDPSRAPIAudioStream.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IRDPSRAPIAudioStream, @ptrCast(self)), pnPeriodInHundredNsIntervals);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAudioStream_Start(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIAudioStream.VTable, @ptrCast(self.vtable)).Start(@as(*const IRDPSRAPIAudioStream, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAudioStream_Stop(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIAudioStream.VTable, @ptrCast(self.vtable)).Stop(@as(*const IRDPSRAPIAudioStream, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAudioStream_GetBuffer(self: *const T, ppbData: [*]?*u8, pcbData: ?*u32, pTimestamp: ?*u64) HRESULT {
                return @as(*const IRDPSRAPIAudioStream.VTable, @ptrCast(self.vtable)).GetBuffer(@as(*const IRDPSRAPIAudioStream, @ptrCast(self)), ppbData, pcbData, pTimestamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAudioStream_FreeBuffer(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIAudioStream.VTable, @ptrCast(self.vtable)).FreeBuffer(@as(*const IRDPSRAPIAudioStream, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IRDPSRAPIClipboardUseEvents_Value = Guid.initString("d559f59a-7a27-4138-8763-247ce5f659a8");
pub const IID_IRDPSRAPIClipboardUseEvents = &IID_IRDPSRAPIClipboardUseEvents_Value;
pub const IRDPSRAPIClipboardUseEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnPasteFromClipboard: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIClipboardUseEvents,
                clipboardFormat: u32,
                pAttendee: ?*IDispatch,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIClipboardUseEvents,
                clipboardFormat: u32,
                pAttendee: ?*IDispatch,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIClipboardUseEvents_OnPasteFromClipboard(self: *const T, clipboardFormat: u32, pAttendee: ?*IDispatch, pRetVal: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIClipboardUseEvents.VTable, @ptrCast(self.vtable)).OnPasteFromClipboard(@as(*const IRDPSRAPIClipboardUseEvents, @ptrCast(self)), clipboardFormat, pAttendee, pRetVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIWindow_Value = Guid.initString("beafe0f9-c77b-4933-ba9f-a24cddcc27cf");
pub const IID_IRDPSRAPIWindow = &IID_IRDPSRAPIWindow_Value;
pub const IRDPSRAPIWindow = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Application: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                pApplication: ?*?*IRDPSRAPIApplication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                pApplication: ?*?*IRDPSRAPIApplication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Shared: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Shared: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                pRetVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Show: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIWindow,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindow,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindow,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_get_Id(self: *const T, pRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IRDPSRAPIWindow, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_get_Application(self: *const T, pApplication: ?*?*IRDPSRAPIApplication) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).get_Application(@as(*const IRDPSRAPIWindow, @ptrCast(self)), pApplication);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_get_Shared(self: *const T, pRetVal: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).get_Shared(@as(*const IRDPSRAPIWindow, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_put_Shared(self: *const T, NewVal: i16) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).put_Shared(@as(*const IRDPSRAPIWindow, @ptrCast(self)), NewVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_get_Name(self: *const T, pRetVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IRDPSRAPIWindow, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_Show(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).Show(@as(*const IRDPSRAPIWindow, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindow_get_Flags(self: *const T, pdwFlags: ?*u32) HRESULT {
                return @as(*const IRDPSRAPIWindow.VTable, @ptrCast(self.vtable)).get_Flags(@as(*const IRDPSRAPIWindow, @ptrCast(self)), pdwFlags);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIWindowList_Value = Guid.initString("8a05ce44-715a-4116-a189-a118f30a07bd");
pub const IID_IRDPSRAPIWindowList = &IID_IRDPSRAPIWindowList_Value;
pub const IRDPSRAPIWindowList = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindowList,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindowList,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIWindowList,
                item: i32,
                pWindow: ?*?*IRDPSRAPIWindow,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIWindowList,
                item: i32,
                pWindow: ?*?*IRDPSRAPIWindow,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindowList_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIWindowList.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IRDPSRAPIWindowList, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIWindowList_get_Item(self: *const T, item: i32, pWindow: ?*?*IRDPSRAPIWindow) HRESULT {
                return @as(*const IRDPSRAPIWindowList.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IRDPSRAPIWindowList, @ptrCast(self)), item, pWindow);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIApplication_Value = Guid.initString("41e7a09d-eb7a-436e-935d-780ca2628324");
pub const IID_IRDPSRAPIApplication = &IID_IRDPSRAPIApplication_Value;
pub const IRDPSRAPIApplication = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Windows: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                pWindowList: ?*?*IRDPSRAPIWindowList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                pWindowList: ?*?*IRDPSRAPIWindowList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Shared: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Shared: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                pRetVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplication,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplication,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_get_Windows(self: *const T, pWindowList: ?*?*IRDPSRAPIWindowList) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).get_Windows(@as(*const IRDPSRAPIApplication, @ptrCast(self)), pWindowList);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_get_Id(self: *const T, pRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IRDPSRAPIApplication, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_get_Shared(self: *const T, pRetVal: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).get_Shared(@as(*const IRDPSRAPIApplication, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_put_Shared(self: *const T, NewVal: i16) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).put_Shared(@as(*const IRDPSRAPIApplication, @ptrCast(self)), NewVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_get_Name(self: *const T, pRetVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IRDPSRAPIApplication, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplication_get_Flags(self: *const T, pdwFlags: ?*u32) HRESULT {
                return @as(*const IRDPSRAPIApplication.VTable, @ptrCast(self.vtable)).get_Flags(@as(*const IRDPSRAPIApplication, @ptrCast(self)), pdwFlags);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIApplicationList_Value = Guid.initString("d4b4aeb3-22dc-4837-b3b6-42ea2517849a");
pub const IID_IRDPSRAPIApplicationList = &IID_IRDPSRAPIApplicationList_Value;
pub const IRDPSRAPIApplicationList = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationList,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationList,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationList,
                item: i32,
                pApplication: ?*?*IRDPSRAPIApplication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationList,
                item: i32,
                pApplication: ?*?*IRDPSRAPIApplication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationList_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIApplicationList.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IRDPSRAPIApplicationList, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationList_get_Item(self: *const T, item: i32, pApplication: ?*?*IRDPSRAPIApplication) HRESULT {
                return @as(*const IRDPSRAPIApplicationList.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IRDPSRAPIApplicationList, @ptrCast(self)), item, pApplication);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIApplicationFilter_Value = Guid.initString("d20f10ca-6637-4f06-b1d5-277ea7e5160d");
pub const IID_IRDPSRAPIApplicationFilter = &IID_IRDPSRAPIApplicationFilter_Value;
pub const IRDPSRAPIApplicationFilter = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Applications: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationFilter,
                pApplications: ?*?*IRDPSRAPIApplicationList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationFilter,
                pApplications: ?*?*IRDPSRAPIApplicationList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Windows: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationFilter,
                pWindows: ?*?*IRDPSRAPIWindowList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationFilter,
                pWindows: ?*?*IRDPSRAPIWindowList,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Enabled: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationFilter,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationFilter,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Enabled: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIApplicationFilter,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIApplicationFilter,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationFilter_get_Applications(self: *const T, pApplications: ?*?*IRDPSRAPIApplicationList) HRESULT {
                return @as(*const IRDPSRAPIApplicationFilter.VTable, @ptrCast(self.vtable)).get_Applications(@as(*const IRDPSRAPIApplicationFilter, @ptrCast(self)), pApplications);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationFilter_get_Windows(self: *const T, pWindows: ?*?*IRDPSRAPIWindowList) HRESULT {
                return @as(*const IRDPSRAPIApplicationFilter.VTable, @ptrCast(self.vtable)).get_Windows(@as(*const IRDPSRAPIApplicationFilter, @ptrCast(self)), pWindows);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationFilter_get_Enabled(self: *const T, pRetVal: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIApplicationFilter.VTable, @ptrCast(self.vtable)).get_Enabled(@as(*const IRDPSRAPIApplicationFilter, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIApplicationFilter_put_Enabled(self: *const T, NewVal: i16) HRESULT {
                return @as(*const IRDPSRAPIApplicationFilter.VTable, @ptrCast(self.vtable)).put_Enabled(@as(*const IRDPSRAPIApplicationFilter, @ptrCast(self)), NewVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPISessionProperties_Value = Guid.initString("339b24f2-9bc0-4f16-9aac-f165433d13d4");
pub const IID_IRDPSRAPISessionProperties = &IID_IRDPSRAPISessionProperties_Value;
pub const IRDPSRAPISessionProperties = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Property: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISessionProperties,
                PropertyName: ?BSTR,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISessionProperties,
                PropertyName: ?BSTR,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Property: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISessionProperties,
                PropertyName: ?BSTR,
                newVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISessionProperties,
                PropertyName: ?BSTR,
                newVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISessionProperties_get_Property(self: *const T, PropertyName: ?BSTR, pVal: ?*VARIANT) HRESULT {
                return @as(*const IRDPSRAPISessionProperties.VTable, @ptrCast(self.vtable)).get_Property(@as(*const IRDPSRAPISessionProperties, @ptrCast(self)), PropertyName, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISessionProperties_put_Property(self: *const T, PropertyName: ?BSTR, newVal: VARIANT) HRESULT {
                return @as(*const IRDPSRAPISessionProperties.VTable, @ptrCast(self.vtable)).put_Property(@as(*const IRDPSRAPISessionProperties, @ptrCast(self)), PropertyName, newVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIInvitation_Value = Guid.initString("4fac1d43-fc51-45bb-b1b4-2b53aa562fa3");
pub const IID_IRDPSRAPIInvitation = &IID_IRDPSRAPIInvitation_Value;
pub const IRDPSRAPIInvitation = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ConnectionString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GroupName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Password: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                pbstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AttendeeLimit: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AttendeeLimit: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                NewVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                NewVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Revoked: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                pRetVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Revoked: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitation,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitation,
                NewVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_get_ConnectionString(self: *const T, pbstrVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).get_ConnectionString(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), pbstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_get_GroupName(self: *const T, pbstrVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).get_GroupName(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), pbstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_get_Password(self: *const T, pbstrVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).get_Password(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), pbstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_get_AttendeeLimit(self: *const T, pRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).get_AttendeeLimit(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_put_AttendeeLimit(self: *const T, NewVal: i32) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).put_AttendeeLimit(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), NewVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_get_Revoked(self: *const T, pRetVal: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).get_Revoked(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitation_put_Revoked(self: *const T, NewVal: i16) HRESULT {
                return @as(*const IRDPSRAPIInvitation.VTable, @ptrCast(self.vtable)).put_Revoked(@as(*const IRDPSRAPIInvitation, @ptrCast(self)), NewVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIInvitationManager_Value = Guid.initString("4722b049-92c3-4c2d-8a65-f7348f644dcf");
pub const IID_IRDPSRAPIInvitationManager = &IID_IRDPSRAPIInvitationManager_Value;
pub const IRDPSRAPIInvitationManager = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitationManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitationManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitationManager,
                item: VARIANT,
                ppInvitation: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitationManager,
                item: VARIANT,
                ppInvitation: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIInvitationManager,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIInvitationManager,
                pRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateInvitation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIInvitationManager,
                bstrAuthString: ?BSTR,
                bstrGroupName: ?BSTR,
                bstrPassword: ?BSTR,
                AttendeeLimit: i32,
                ppInvitation: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIInvitationManager,
                bstrAuthString: ?BSTR,
                bstrGroupName: ?BSTR,
                bstrPassword: ?BSTR,
                AttendeeLimit: i32,
                ppInvitation: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitationManager_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIInvitationManager.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IRDPSRAPIInvitationManager, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitationManager_get_Item(self: *const T, item: VARIANT, ppInvitation: ?*?*IRDPSRAPIInvitation) HRESULT {
                return @as(*const IRDPSRAPIInvitationManager.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IRDPSRAPIInvitationManager, @ptrCast(self)), item, ppInvitation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitationManager_get_Count(self: *const T, pRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIInvitationManager.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IRDPSRAPIInvitationManager, @ptrCast(self)), pRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIInvitationManager_CreateInvitation(self: *const T, bstrAuthString: ?BSTR, bstrGroupName: ?BSTR, bstrPassword: ?BSTR, AttendeeLimit: i32, ppInvitation: ?*?*IRDPSRAPIInvitation) HRESULT {
                return @as(*const IRDPSRAPIInvitationManager.VTable, @ptrCast(self.vtable)).CreateInvitation(@as(*const IRDPSRAPIInvitationManager, @ptrCast(self)), bstrAuthString, bstrGroupName, bstrPassword, AttendeeLimit, ppInvitation);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPITcpConnectionInfo_Value = Guid.initString("f74049a4-3d06-4028-8193-0a8c29bc2452");
pub const IID_IRDPSRAPITcpConnectionInfo = &IID_IRDPSRAPITcpConnectionInfo_Value;
pub const IRDPSRAPITcpConnectionInfo = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Protocol: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plProtocol: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plProtocol: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LocalPort: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plPort: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plPort: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LocalIP: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                pbsrLocalIP: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                pbsrLocalIP: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PeerPort: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plPort: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                plPort: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PeerIP: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                pbstrIP: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITcpConnectionInfo,
                pbstrIP: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITcpConnectionInfo_get_Protocol(self: *const T, plProtocol: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITcpConnectionInfo.VTable, @ptrCast(self.vtable)).get_Protocol(@as(*const IRDPSRAPITcpConnectionInfo, @ptrCast(self)), plProtocol);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITcpConnectionInfo_get_LocalPort(self: *const T, plPort: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITcpConnectionInfo.VTable, @ptrCast(self.vtable)).get_LocalPort(@as(*const IRDPSRAPITcpConnectionInfo, @ptrCast(self)), plPort);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITcpConnectionInfo_get_LocalIP(self: *const T, pbsrLocalIP: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPITcpConnectionInfo.VTable, @ptrCast(self.vtable)).get_LocalIP(@as(*const IRDPSRAPITcpConnectionInfo, @ptrCast(self)), pbsrLocalIP);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITcpConnectionInfo_get_PeerPort(self: *const T, plPort: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITcpConnectionInfo.VTable, @ptrCast(self.vtable)).get_PeerPort(@as(*const IRDPSRAPITcpConnectionInfo, @ptrCast(self)), plPort);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITcpConnectionInfo_get_PeerIP(self: *const T, pbstrIP: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPITcpConnectionInfo.VTable, @ptrCast(self.vtable)).get_PeerIP(@as(*const IRDPSRAPITcpConnectionInfo, @ptrCast(self)), pbstrIP);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIAttendee_Value = Guid.initString("ec0671b3-1b78-4b80-a464-9132247543e3");
pub const IID_IRDPSRAPIAttendee = &IID_IRDPSRAPIAttendee_Value;
pub const IRDPSRAPIAttendee = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                pId: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                pId: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RemoteName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ControlLevel: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                pVal: ?*CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                pVal: ?*CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ControlLevel: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                pNewVal: CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                pNewVal: CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Invitation: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                ppVal: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                ppVal: ?*?*IRDPSRAPIInvitation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        TerminateConnection: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ConnectivityInfo: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendee,
                ppVal: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendee,
                ppVal: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_Id(self: *const T, pId: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), pId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_RemoteName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_RemoteName(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_ControlLevel(self: *const T, pVal: ?*CTRL_LEVEL) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_ControlLevel(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_put_ControlLevel(self: *const T, pNewVal: CTRL_LEVEL) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).put_ControlLevel(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), pNewVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_Invitation(self: *const T, ppVal: ?*?*IRDPSRAPIInvitation) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_Invitation(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_TerminateConnection(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).TerminateConnection(@as(*const IRDPSRAPIAttendee, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_Flags(self: *const T, plFlags: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_Flags(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), plFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendee_get_ConnectivityInfo(self: *const T, ppVal: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIAttendee.VTable, @ptrCast(self.vtable)).get_ConnectivityInfo(@as(*const IRDPSRAPIAttendee, @ptrCast(self)), ppVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIAttendeeManager_Value = Guid.initString("ba3a37e8-33da-4749-8da0-07fa34da7944");
pub const IID_IRDPSRAPIAttendeeManager = &IID_IRDPSRAPIAttendeeManager_Value;
pub const IRDPSRAPIAttendeeManager = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendeeManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendeeManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendeeManager,
                id: i32,
                ppItem: ?*?*IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendeeManager,
                id: i32,
                ppItem: ?*?*IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendeeManager_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIAttendeeManager.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IRDPSRAPIAttendeeManager, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendeeManager_get_Item(self: *const T, id: i32, ppItem: ?*?*IRDPSRAPIAttendee) HRESULT {
                return @as(*const IRDPSRAPIAttendeeManager.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IRDPSRAPIAttendeeManager, @ptrCast(self)), id, ppItem);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIAttendeeDisconnectInfo_Value = Guid.initString("c187689f-447c-44a1-9c14-fffbb3b7ec17");
pub const IID_IRDPSRAPIAttendeeDisconnectInfo = &IID_IRDPSRAPIAttendeeDisconnectInfo_Value;
pub const IRDPSRAPIAttendeeDisconnectInfo = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Attendee: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                retval: ?*?*IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                retval: ?*?*IRDPSRAPIAttendee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Reason: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                pReason: ?*ATTENDEE_DISCONNECT_REASON,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                pReason: ?*ATTENDEE_DISCONNECT_REASON,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Code: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIAttendeeDisconnectInfo,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendeeDisconnectInfo_get_Attendee(self: *const T, retval: ?*?*IRDPSRAPIAttendee) HRESULT {
                return @as(*const IRDPSRAPIAttendeeDisconnectInfo.VTable, @ptrCast(self.vtable)).get_Attendee(@as(*const IRDPSRAPIAttendeeDisconnectInfo, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendeeDisconnectInfo_get_Reason(self: *const T, pReason: ?*ATTENDEE_DISCONNECT_REASON) HRESULT {
                return @as(*const IRDPSRAPIAttendeeDisconnectInfo.VTable, @ptrCast(self.vtable)).get_Reason(@as(*const IRDPSRAPIAttendeeDisconnectInfo, @ptrCast(self)), pReason);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIAttendeeDisconnectInfo_get_Code(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIAttendeeDisconnectInfo.VTable, @ptrCast(self.vtable)).get_Code(@as(*const IRDPSRAPIAttendeeDisconnectInfo, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIVirtualChannel_Value = Guid.initString("05e12f95-28b3-4c9a-8780-d0248574a1e0");
pub const IID_IRDPSRAPIVirtualChannel = &IID_IRDPSRAPIVirtualChannel_Value;
pub const IRDPSRAPIVirtualChannel = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        SendData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannel,
                bstrData: ?BSTR,
                lAttendeeId: i32,
                ChannelSendFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannel,
                bstrData: ?BSTR,
                lAttendeeId: i32,
                ChannelSendFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAccess: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannel,
                lAttendeeId: i32,
                AccessType: CHANNEL_ACCESS_ENUM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannel,
                lAttendeeId: i32,
                AccessType: CHANNEL_ACCESS_ENUM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannel,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannel,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannel,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannel,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Priority: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannel,
                pPriority: ?*CHANNEL_PRIORITY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannel,
                pPriority: ?*CHANNEL_PRIORITY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannel_SendData(self: *const T, bstrData: ?BSTR, lAttendeeId: i32, ChannelSendFlags: u32) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannel.VTable, @ptrCast(self.vtable)).SendData(@as(*const IRDPSRAPIVirtualChannel, @ptrCast(self)), bstrData, lAttendeeId, ChannelSendFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannel_SetAccess(self: *const T, lAttendeeId: i32, AccessType: CHANNEL_ACCESS_ENUM) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannel.VTable, @ptrCast(self.vtable)).SetAccess(@as(*const IRDPSRAPIVirtualChannel, @ptrCast(self)), lAttendeeId, AccessType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannel_get_Name(self: *const T, pbstrName: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannel.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IRDPSRAPIVirtualChannel, @ptrCast(self)), pbstrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannel_get_Flags(self: *const T, plFlags: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannel.VTable, @ptrCast(self.vtable)).get_Flags(@as(*const IRDPSRAPIVirtualChannel, @ptrCast(self)), plFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannel_get_Priority(self: *const T, pPriority: ?*CHANNEL_PRIORITY) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannel.VTable, @ptrCast(self.vtable)).get_Priority(@as(*const IRDPSRAPIVirtualChannel, @ptrCast(self)), pPriority);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIVirtualChannelManager_Value = Guid.initString("0d11c661-5d0d-4ee4-89df-2166ae1fdfed");
pub const IID_IRDPSRAPIVirtualChannelManager = &IID_IRDPSRAPIVirtualChannelManager_Value;
pub const IRDPSRAPIVirtualChannelManager = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                retval: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                item: VARIANT,
                pChannel: ?*?*IRDPSRAPIVirtualChannel,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                item: VARIANT,
                pChannel: ?*?*IRDPSRAPIVirtualChannel,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateVirtualChannel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                bstrChannelName: ?BSTR,
                Priority: CHANNEL_PRIORITY,
                ChannelFlags: u32,
                ppChannel: ?*?*IRDPSRAPIVirtualChannel,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIVirtualChannelManager,
                bstrChannelName: ?BSTR,
                Priority: CHANNEL_PRIORITY,
                ChannelFlags: u32,
                ppChannel: ?*?*IRDPSRAPIVirtualChannel,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannelManager_get__NewEnum(self: *const T, retval: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannelManager.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IRDPSRAPIVirtualChannelManager, @ptrCast(self)), retval);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannelManager_get_Item(self: *const T, item: VARIANT, pChannel: ?*?*IRDPSRAPIVirtualChannel) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannelManager.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IRDPSRAPIVirtualChannelManager, @ptrCast(self)), item, pChannel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIVirtualChannelManager_CreateVirtualChannel(self: *const T, bstrChannelName: ?BSTR, Priority: CHANNEL_PRIORITY, ChannelFlags: u32, ppChannel: ?*?*IRDPSRAPIVirtualChannel) HRESULT {
                return @as(*const IRDPSRAPIVirtualChannelManager.VTable, @ptrCast(self.vtable)).CreateVirtualChannel(@as(*const IRDPSRAPIVirtualChannelManager, @ptrCast(self)), bstrChannelName, Priority, ChannelFlags, ppChannel);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPIViewer_Value = Guid.initString("c6bfcd38-8ce9-404d-8ae8-f31d00c65cb5");
pub const IID_IRDPSRAPIViewer = &IID_IRDPSRAPIViewer_Value;
pub const IRDPSRAPIViewer = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Connect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                bstrConnectionString: ?BSTR,
                bstrName: ?BSTR,
                bstrPassword: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                bstrConnectionString: ?BSTR,
                bstrName: ?BSTR,
                bstrPassword: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Disconnect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIViewer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Attendees: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIAttendeeManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIAttendeeManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Invitations: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIInvitationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIInvitationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ApplicationFilter: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIApplicationFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIApplicationFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_VirtualChannelManager: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIVirtualChannelManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPIVirtualChannelManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_SmartSizing: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                vbSmartSizing: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                vbSmartSizing: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SmartSizing: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                pvbSmartSizing: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                pvbSmartSizing: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestControl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                CtrlLevel: CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                CtrlLevel: CTRL_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_DisconnectedText: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                bstrDisconnectedText: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                bstrDisconnectedText: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisconnectedText: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                pbstrDisconnectedText: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                pbstrDisconnectedText: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestColorDepthChange: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                Bpp: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                Bpp: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Properties: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPISessionProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                ppVal: ?*?*IRDPSRAPISessionProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        StartReverseConnectListener: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIViewer,
                bstrConnectionString: ?BSTR,
                bstrUserName: ?BSTR,
                bstrPassword: ?BSTR,
                pbstrReverseConnectString: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIViewer,
                bstrConnectionString: ?BSTR,
                bstrUserName: ?BSTR,
                bstrPassword: ?BSTR,
                pbstrReverseConnectString: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_Connect(self: *const T, bstrConnectionString: ?BSTR, bstrName: ?BSTR, bstrPassword: ?BSTR) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).Connect(@as(*const IRDPSRAPIViewer, @ptrCast(self)), bstrConnectionString, bstrName, bstrPassword);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_Disconnect(self: *const T) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).Disconnect(@as(*const IRDPSRAPIViewer, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_Attendees(self: *const T, ppVal: ?*?*IRDPSRAPIAttendeeManager) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_Attendees(@as(*const IRDPSRAPIViewer, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_Invitations(self: *const T, ppVal: ?*?*IRDPSRAPIInvitationManager) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_Invitations(@as(*const IRDPSRAPIViewer, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_ApplicationFilter(self: *const T, ppVal: ?*?*IRDPSRAPIApplicationFilter) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_ApplicationFilter(@as(*const IRDPSRAPIViewer, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_VirtualChannelManager(self: *const T, ppVal: ?*?*IRDPSRAPIVirtualChannelManager) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_VirtualChannelManager(@as(*const IRDPSRAPIViewer, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_put_SmartSizing(self: *const T, vbSmartSizing: i16) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).put_SmartSizing(@as(*const IRDPSRAPIViewer, @ptrCast(self)), vbSmartSizing);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_SmartSizing(self: *const T, pvbSmartSizing: ?*i16) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_SmartSizing(@as(*const IRDPSRAPIViewer, @ptrCast(self)), pvbSmartSizing);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_RequestControl(self: *const T, CtrlLevel: CTRL_LEVEL) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).RequestControl(@as(*const IRDPSRAPIViewer, @ptrCast(self)), CtrlLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_put_DisconnectedText(self: *const T, bstrDisconnectedText: ?BSTR) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).put_DisconnectedText(@as(*const IRDPSRAPIViewer, @ptrCast(self)), bstrDisconnectedText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_DisconnectedText(self: *const T, pbstrDisconnectedText: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_DisconnectedText(@as(*const IRDPSRAPIViewer, @ptrCast(self)), pbstrDisconnectedText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_RequestColorDepthChange(self: *const T, Bpp: i32) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).RequestColorDepthChange(@as(*const IRDPSRAPIViewer, @ptrCast(self)), Bpp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_get_Properties(self: *const T, ppVal: ?*?*IRDPSRAPISessionProperties) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).get_Properties(@as(*const IRDPSRAPIViewer, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIViewer_StartReverseConnectListener(self: *const T, bstrConnectionString: ?BSTR, bstrUserName: ?BSTR, bstrPassword: ?BSTR, pbstrReverseConnectString: ?*?BSTR) HRESULT {
                return @as(*const IRDPSRAPIViewer.VTable, @ptrCast(self.vtable)).StartReverseConnectListener(@as(*const IRDPSRAPIViewer, @ptrCast(self)), bstrConnectionString, bstrUserName, bstrPassword, pbstrReverseConnectString);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.1'
const IID_IRDPViewerInputSink_Value = Guid.initString("bb590853-a6c5-4a7b-8dd4-76b69eea12d5");
pub const IID_IRDPViewerInputSink = &IID_IRDPViewerInputSink_Value;
pub const IRDPViewerInputSink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SendMouseButtonEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                buttonType: RDPSRAPI_MOUSE_BUTTON_TYPE,
                vbButtonDown: i16,
                xPos: u32,
                yPos: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                buttonType: RDPSRAPI_MOUSE_BUTTON_TYPE,
                vbButtonDown: i16,
                xPos: u32,
                yPos: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendMouseMoveEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                xPos: u32,
                yPos: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                xPos: u32,
                yPos: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendMouseWheelEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                wheelRotation: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                wheelRotation: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendKeyboardEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                codeType: RDPSRAPI_KBD_CODE_TYPE,
                keycode: u16,
                vbKeyUp: i16,
                vbRepeat: i16,
                vbExtended: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                codeType: RDPSRAPI_KBD_CODE_TYPE,
                keycode: u16,
                vbKeyUp: i16,
                vbRepeat: i16,
                vbExtended: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendSyncEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                syncFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                syncFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginTouchFrame: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddTouchInput: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
                contactId: u32,
                event: u32,
                x: i32,
                y: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
                contactId: u32,
                event: u32,
                x: i32,
                y: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EndTouchFrame: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPViewerInputSink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPViewerInputSink,
            ) 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 IRDPViewerInputSink_SendMouseButtonEvent(self: *const T, buttonType: RDPSRAPI_MOUSE_BUTTON_TYPE, vbButtonDown: i16, xPos: u32, yPos: u32) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).SendMouseButtonEvent(@as(*const IRDPViewerInputSink, @ptrCast(self)), buttonType, vbButtonDown, xPos, yPos);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_SendMouseMoveEvent(self: *const T, xPos: u32, yPos: u32) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).SendMouseMoveEvent(@as(*const IRDPViewerInputSink, @ptrCast(self)), xPos, yPos);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_SendMouseWheelEvent(self: *const T, wheelRotation: u16) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).SendMouseWheelEvent(@as(*const IRDPViewerInputSink, @ptrCast(self)), wheelRotation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_SendKeyboardEvent(self: *const T, codeType: RDPSRAPI_KBD_CODE_TYPE, keycode: u16, vbKeyUp: i16, vbRepeat: i16, vbExtended: i16) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).SendKeyboardEvent(@as(*const IRDPViewerInputSink, @ptrCast(self)), codeType, keycode, vbKeyUp, vbRepeat, vbExtended);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_SendSyncEvent(self: *const T, syncFlags: u32) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).SendSyncEvent(@as(*const IRDPViewerInputSink, @ptrCast(self)), syncFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_BeginTouchFrame(self: *const T) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).BeginTouchFrame(@as(*const IRDPViewerInputSink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_AddTouchInput(self: *const T, contactId: u32, event: u32, x: i32, y: i32) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).AddTouchInput(@as(*const IRDPViewerInputSink, @ptrCast(self)), contactId, event, x, y);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPViewerInputSink_EndTouchFrame(self: *const T) HRESULT {
                return @as(*const IRDPViewerInputSink.VTable, @ptrCast(self.vtable)).EndTouchFrame(@as(*const IRDPViewerInputSink, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IRDPSRAPIFrameBuffer_Value = Guid.initString("3d67e7d2-b27b-448e-81b3-c6110ed8b4be");
pub const IID_IRDPSRAPIFrameBuffer = &IID_IRDPSRAPIFrameBuffer_Value;
pub const IRDPSRAPIFrameBuffer = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Width: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIFrameBuffer,
                plWidth: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIFrameBuffer,
                plWidth: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Height: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIFrameBuffer,
                plHeight: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIFrameBuffer,
                plHeight: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Bpp: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPIFrameBuffer,
                plBpp: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPIFrameBuffer,
                plBpp: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFrameBufferBits: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPIFrameBuffer,
                x: i32,
                y: i32,
                Width: i32,
                Heigth: i32,
                ppBits: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPIFrameBuffer,
                x: i32,
                y: i32,
                Width: i32,
                Heigth: i32,
                ppBits: ?*?*SAFEARRAY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIFrameBuffer_get_Width(self: *const T, plWidth: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIFrameBuffer.VTable, @ptrCast(self.vtable)).get_Width(@as(*const IRDPSRAPIFrameBuffer, @ptrCast(self)), plWidth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIFrameBuffer_get_Height(self: *const T, plHeight: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIFrameBuffer.VTable, @ptrCast(self.vtable)).get_Height(@as(*const IRDPSRAPIFrameBuffer, @ptrCast(self)), plHeight);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIFrameBuffer_get_Bpp(self: *const T, plBpp: ?*i32) HRESULT {
                return @as(*const IRDPSRAPIFrameBuffer.VTable, @ptrCast(self.vtable)).get_Bpp(@as(*const IRDPSRAPIFrameBuffer, @ptrCast(self)), plBpp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPIFrameBuffer_GetFrameBufferBits(self: *const T, x: i32, y: i32, Width: i32, Heigth: i32, ppBits: ?*?*SAFEARRAY) HRESULT {
                return @as(*const IRDPSRAPIFrameBuffer.VTable, @ptrCast(self.vtable)).GetFrameBufferBits(@as(*const IRDPSRAPIFrameBuffer, @ptrCast(self)), x, y, Width, Heigth, ppBits);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IRDPSRAPITransportStreamBuffer_Value = Guid.initString("81c80290-5085-44b0-b460-f865c39cb4a9");
pub const IID_IRDPSRAPITransportStreamBuffer = &IID_IRDPSRAPITransportStreamBuffer_Value;
pub const IRDPSRAPITransportStreamBuffer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Storage: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                ppbStorage: ?*?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                ppbStorage: ?*?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StorageSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plMaxStore: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plMaxStore: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PayloadSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PayloadSize: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PayloadOffset: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plRetVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PayloadOffset: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lRetVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lRetVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                plFlags: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Flags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lFlags: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                lFlags: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Context: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                ppContext: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                ppContext: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Context: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                pContext: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPITransportStreamBuffer,
                pContext: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_Storage(self: *const T, ppbStorage: ?*?*u8) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_Storage(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), ppbStorage);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_StorageSize(self: *const T, plMaxStore: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_StorageSize(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), plMaxStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_PayloadSize(self: *const T, plRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_PayloadSize(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), plRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_put_PayloadSize(self: *const T, lVal: i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).put_PayloadSize(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_PayloadOffset(self: *const T, plRetVal: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_PayloadOffset(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), plRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_put_PayloadOffset(self: *const T, lRetVal: i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).put_PayloadOffset(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), lRetVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_Flags(self: *const T, plFlags: ?*i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_Flags(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), plFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_put_Flags(self: *const T, lFlags: i32) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).put_Flags(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), lFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_get_Context(self: *const T, ppContext: ?*?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).get_Context(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), ppContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamBuffer_put_Context(self: *const T, pContext: ?*IUnknown) HRESULT {
                return @as(*const IRDPSRAPITransportStreamBuffer.VTable, @ptrCast(self.vtable)).put_Context(@as(*const IRDPSRAPITransportStreamBuffer, @ptrCast(self)), pContext);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IRDPSRAPITransportStreamEvents_Value = Guid.initString("ea81c254-f5af-4e40-982e-3e63bb595276");
pub const IID_IRDPSRAPITransportStreamEvents = &IID_IRDPSRAPITransportStreamEvents_Value;
pub const IRDPSRAPITransportStreamEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnWriteCompleted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamEvents,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IRDPSRAPITransportStreamEvents,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        OnReadCompleted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamEvents,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IRDPSRAPITransportStreamEvents,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        OnStreamClosed: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStreamEvents,
                hrReason: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IRDPSRAPITransportStreamEvents,
                hrReason: HRESULT,
            ) 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 IRDPSRAPITransportStreamEvents_OnWriteCompleted(self: *const T, pBuffer: ?*IRDPSRAPITransportStreamBuffer) void {
                return @as(*const IRDPSRAPITransportStreamEvents.VTable, @ptrCast(self.vtable)).OnWriteCompleted(@as(*const IRDPSRAPITransportStreamEvents, @ptrCast(self)), pBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamEvents_OnReadCompleted(self: *const T, pBuffer: ?*IRDPSRAPITransportStreamBuffer) void {
                return @as(*const IRDPSRAPITransportStreamEvents.VTable, @ptrCast(self.vtable)).OnReadCompleted(@as(*const IRDPSRAPITransportStreamEvents, @ptrCast(self)), pBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStreamEvents_OnStreamClosed(self: *const T, hrReason: HRESULT) void {
                return @as(*const IRDPSRAPITransportStreamEvents.VTable, @ptrCast(self.vtable)).OnStreamClosed(@as(*const IRDPSRAPITransportStreamEvents, @ptrCast(self)), hrReason);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IRDPSRAPITransportStream_Value = Guid.initString("36cfa065-43bb-4ef7-aed7-9b88a5053036");
pub const IID_IRDPSRAPITransportStream = &IID_IRDPSRAPITransportStream_Value;
pub const IRDPSRAPITransportStream = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AllocBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
                maxPayload: i32,
                ppBuffer: ?*?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
                maxPayload: i32,
                ppBuffer: ?*?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FreeBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReadBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
                pBuffer: ?*IRDPSRAPITransportStreamBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Open: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
                pCallbacks: ?*IRDPSRAPITransportStreamEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
                pCallbacks: ?*IRDPSRAPITransportStreamEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPITransportStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPITransportStream,
            ) 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 IRDPSRAPITransportStream_AllocBuffer(self: *const T, maxPayload: i32, ppBuffer: ?*?*IRDPSRAPITransportStreamBuffer) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).AllocBuffer(@as(*const IRDPSRAPITransportStream, @ptrCast(self)), maxPayload, ppBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStream_FreeBuffer(self: *const T, pBuffer: ?*IRDPSRAPITransportStreamBuffer) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).FreeBuffer(@as(*const IRDPSRAPITransportStream, @ptrCast(self)), pBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStream_WriteBuffer(self: *const T, pBuffer: ?*IRDPSRAPITransportStreamBuffer) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).WriteBuffer(@as(*const IRDPSRAPITransportStream, @ptrCast(self)), pBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStream_ReadBuffer(self: *const T, pBuffer: ?*IRDPSRAPITransportStreamBuffer) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).ReadBuffer(@as(*const IRDPSRAPITransportStream, @ptrCast(self)), pBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStream_Open(self: *const T, pCallbacks: ?*IRDPSRAPITransportStreamEvents) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).Open(@as(*const IRDPSRAPITransportStream, @ptrCast(self)), pCallbacks);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPITransportStream_Close(self: *const T) HRESULT {
                return @as(*const IRDPSRAPITransportStream.VTable, @ptrCast(self.vtable)).Close(@as(*const IRDPSRAPITransportStream, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRDPSRAPISharingSession_Value = Guid.initString("eeb20886-e470-4cf6-842b-2739c0ec5cfb");
pub const IID_IRDPSRAPISharingSession = &IID_IRDPSRAPISharingSession_Value;
pub const IRDPSRAPISharingSession = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Open: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ColorDepth: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                colorDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                colorDepth: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ColorDepth: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                pColorDepth: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                pColorDepth: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Properties: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPISessionProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPISessionProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Attendees: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIAttendeeManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIAttendeeManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Invitations: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIInvitationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIInvitationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ApplicationFilter: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIApplicationFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIApplicationFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_VirtualChannelManager: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIVirtualChannelManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                ppVal: ?*?*IRDPSRAPIVirtualChannelManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Pause: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Resume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ConnectToClient: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                bstrConnectionString: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                bstrConnectionString: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDesktopSharedRect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                left: i32,
                top: i32,
                right: i32,
                bottom: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                left: i32,
                top: i32,
                right: i32,
                bottom: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDesktopSharedRect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession,
                pleft: ?*i32,
                ptop: ?*i32,
                pright: ?*i32,
                pbottom: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession,
                pleft: ?*i32,
                ptop: ?*i32,
                pright: ?*i32,
                pbottom: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_Open(self: *const T) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).Open(@as(*const IRDPSRAPISharingSession, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_Close(self: *const T) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).Close(@as(*const IRDPSRAPISharingSession, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_put_ColorDepth(self: *const T, colorDepth: i32) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).put_ColorDepth(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), colorDepth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_ColorDepth(self: *const T, pColorDepth: ?*i32) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_ColorDepth(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), pColorDepth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_Properties(self: *const T, ppVal: ?*?*IRDPSRAPISessionProperties) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_Properties(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_Attendees(self: *const T, ppVal: ?*?*IRDPSRAPIAttendeeManager) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_Attendees(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_Invitations(self: *const T, ppVal: ?*?*IRDPSRAPIInvitationManager) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_Invitations(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_ApplicationFilter(self: *const T, ppVal: ?*?*IRDPSRAPIApplicationFilter) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_ApplicationFilter(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_get_VirtualChannelManager(self: *const T, ppVal: ?*?*IRDPSRAPIVirtualChannelManager) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).get_VirtualChannelManager(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_Pause(self: *const T) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).Pause(@as(*const IRDPSRAPISharingSession, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_Resume(self: *const T) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).Resume(@as(*const IRDPSRAPISharingSession, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_ConnectToClient(self: *const T, bstrConnectionString: ?BSTR) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).ConnectToClient(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), bstrConnectionString);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_SetDesktopSharedRect(self: *const T, left: i32, top: i32, right: i32, bottom: i32) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).SetDesktopSharedRect(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), left, top, right, bottom);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession_GetDesktopSharedRect(self: *const T, pleft: ?*i32, ptop: ?*i32, pright: ?*i32, pbottom: ?*i32) HRESULT {
                return @as(*const IRDPSRAPISharingSession.VTable, @ptrCast(self.vtable)).GetDesktopSharedRect(@as(*const IRDPSRAPISharingSession, @ptrCast(self)), pleft, ptop, pright, pbottom);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IRDPSRAPISharingSession2_Value = Guid.initString("fee4ee57-e3e8-4205-8fb0-8fd1d0675c21");
pub const IID_IRDPSRAPISharingSession2 = &IID_IRDPSRAPISharingSession2_Value;
pub const IRDPSRAPISharingSession2 = extern struct {
    pub const VTable = extern struct {
        base: IRDPSRAPISharingSession.VTable,
        ConnectUsingTransportStream: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession2,
                pStream: ?*IRDPSRAPITransportStream,
                bstrGroup: ?BSTR,
                bstrAuthenticatedAttendeeName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession2,
                pStream: ?*IRDPSRAPITransportStream,
                bstrGroup: ?BSTR,
                bstrAuthenticatedAttendeeName: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_FrameBuffer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession2,
                ppVal: ?*?*IRDPSRAPIFrameBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IRDPSRAPISharingSession2,
                ppVal: ?*?*IRDPSRAPIFrameBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendControlLevelChangeResponse: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRDPSRAPISharingSession2,
                pAttendee: ?*IRDPSRAPIAttendee,
                RequestedLevel: CTRL_LEVEL,
                ReasonCode: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRDPSRAPISharingSession2,
                pAttendee: ?*IRDPSRAPIAttendee,
                RequestedLevel: CTRL_LEVEL,
                ReasonCode: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IRDPSRAPISharingSession.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession2_ConnectUsingTransportStream(self: *const T, pStream: ?*IRDPSRAPITransportStream, bstrGroup: ?BSTR, bstrAuthenticatedAttendeeName: ?BSTR) HRESULT {
                return @as(*const IRDPSRAPISharingSession2.VTable, @ptrCast(self.vtable)).ConnectUsingTransportStream(@as(*const IRDPSRAPISharingSession2, @ptrCast(self)), pStream, bstrGroup, bstrAuthenticatedAttendeeName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession2_get_FrameBuffer(self: *const T, ppVal: ?*?*IRDPSRAPIFrameBuffer) HRESULT {
                return @as(*const IRDPSRAPISharingSession2.VTable, @ptrCast(self.vtable)).get_FrameBuffer(@as(*const IRDPSRAPISharingSession2, @ptrCast(self)), ppVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRDPSRAPISharingSession2_SendControlLevelChangeResponse(self: *const T, pAttendee: ?*IRDPSRAPIAttendee, RequestedLevel: CTRL_LEVEL, ReasonCode: i32) HRESULT {
                return @as(*const IRDPSRAPISharingSession2.VTable, @ptrCast(self.vtable)).SendControlLevelChangeResponse(@as(*const IRDPSRAPISharingSession2, @ptrCast(self)), pAttendee, RequestedLevel, ReasonCode);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001 = enum(i32) {
    MAX_CHANNEL_MESSAGE_SIZE = 1024,
    MAX_CHANNEL_NAME_LEN = 8,
    MAX_LEGACY_CHANNEL_MESSAGE_SIZE = 409600,
    ATTENDEE_ID_EVERYONE = -1,
    ATTENDEE_ID_HOST = 0,
    CONN_INTERVAL = 50,
    // ATTENDEE_ID_DEFAULT = -1, this enum value conflicts with ATTENDEE_ID_EVERYONE
};
pub const CONST_MAX_CHANNEL_MESSAGE_SIZE = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.MAX_CHANNEL_MESSAGE_SIZE;
pub const CONST_MAX_CHANNEL_NAME_LEN = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.MAX_CHANNEL_NAME_LEN;
pub const CONST_MAX_LEGACY_CHANNEL_MESSAGE_SIZE = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.MAX_LEGACY_CHANNEL_MESSAGE_SIZE;
pub const CONST_ATTENDEE_ID_EVERYONE = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.ATTENDEE_ID_EVERYONE;
pub const CONST_ATTENDEE_ID_HOST = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.ATTENDEE_ID_HOST;
pub const CONST_CONN_INTERVAL = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.CONN_INTERVAL;
pub const CONST_ATTENDEE_ID_DEFAULT = __MIDL___MIDL_itf_rdpencomapi_0000_0027_0001.ATTENDEE_ID_EVERYONE;

pub const __ReferenceRemainingTypes__ = extern struct {
    __ctrlLevel__: CTRL_LEVEL,
    __attendeeDisconnectReason__: ATTENDEE_DISCONNECT_REASON,
    __channelPriority__: CHANNEL_PRIORITY,
    __channelFlags__: CHANNEL_FLAGS,
    __channelAccessEnum__: CHANNEL_ACCESS_ENUM,
    __rdpencomapiAttendeeFlags__: RDPENCOMAPI_ATTENDEE_FLAGS,
    __rdpsrapiWndFlags__: RDPSRAPI_WND_FLAGS,
    __rdpsrapiAppFlags__: RDPSRAPI_APP_FLAGS,
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID__IRDPSessionEvents_Value = Guid.initString("98a97042-6698-40e9-8efd-b3200990004b");
pub const IID__IRDPSessionEvents = &IID__IRDPSessionEvents_Value;
pub const _IRDPSessionEvents = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (7)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BSTR = @import("../foundation.zig").BSTR;
const HRESULT = @import("../foundation.zig").HRESULT;
const IDispatch = @import("../system/com.zig").IDispatch;
const IUnknown = @import("../system/com.zig").IUnknown;
const SAFEARRAY = @import("../system/com.zig").SAFEARRAY;
const VARIANT = @import("../system/com.zig").VARIANT;

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

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