//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (91)
//--------------------------------------------------------------------------------
pub const GPM_USE_PDC = @as(u32, 0);
pub const GPM_USE_ANYDC = @as(u32, 1);
pub const GPM_DONOTUSE_W2KDC = @as(u32, 2);
pub const GPM_DONOT_VALIDATEDC = @as(u32, 1);
pub const GPM_MIGRATIONTABLE_ONLY = @as(u32, 1);
pub const GPM_PROCESS_SECURITY = @as(u32, 2);
pub const RSOP_NO_COMPUTER = @as(u32, 65536);
pub const RSOP_NO_USER = @as(u32, 131072);
pub const RSOP_PLANNING_ASSUME_SLOW_LINK = @as(u32, 1);
pub const RSOP_PLANNING_ASSUME_LOOPBACK_MERGE = @as(u32, 2);
pub const RSOP_PLANNING_ASSUME_LOOPBACK_REPLACE = @as(u32, 4);
pub const RSOP_PLANNING_ASSUME_USER_WQLFILTER_TRUE = @as(u32, 8);
pub const RSOP_PLANNING_ASSUME_COMP_WQLFILTER_TRUE = @as(u32, 16);
pub const PI_NOUI = @as(u32, 1);
pub const PI_APPLYPOLICY = @as(u32, 2);
pub const PT_TEMPORARY = @as(u32, 1);
pub const PT_ROAMING = @as(u32, 2);
pub const PT_MANDATORY = @as(u32, 4);
pub const PT_ROAMING_PREEXISTING = @as(u32, 8);
pub const RP_FORCE = @as(u32, 1);
pub const RP_SYNC = @as(u32, 2);
pub const GPC_BLOCK_POLICY = @as(u32, 1);
pub const GPO_FLAG_DISABLE = @as(u32, 1);
pub const GPO_FLAG_FORCE = @as(u32, 2);
pub const GPO_LIST_FLAG_MACHINE = @as(u32, 1);
pub const GPO_LIST_FLAG_SITEONLY = @as(u32, 2);
pub const GPO_LIST_FLAG_NO_WMIFILTERS = @as(u32, 4);
pub const GPO_LIST_FLAG_NO_SECURITYFILTERS = @as(u32, 8);
pub const GPO_INFO_FLAG_MACHINE = @as(u32, 1);
pub const GPO_INFO_FLAG_BACKGROUND = @as(u32, 16);
pub const GPO_INFO_FLAG_SLOWLINK = @as(u32, 32);
pub const GPO_INFO_FLAG_VERBOSE = @as(u32, 64);
pub const GPO_INFO_FLAG_NOCHANGES = @as(u32, 128);
pub const GPO_INFO_FLAG_LINKTRANSITION = @as(u32, 256);
pub const GPO_INFO_FLAG_LOGRSOP_TRANSITION = @as(u32, 512);
pub const GPO_INFO_FLAG_FORCED_REFRESH = @as(u32, 1024);
pub const GPO_INFO_FLAG_SAFEMODE_BOOT = @as(u32, 2048);
pub const GPO_INFO_FLAG_ASYNC_FOREGROUND = @as(u32, 4096);
pub const FLAG_NO_GPO_FILTER = @as(u32, 2147483648);
pub const FLAG_NO_CSE_INVOKE = @as(u32, 1073741824);
pub const FLAG_ASSUME_SLOW_LINK = @as(u32, 536870912);
pub const FLAG_LOOPBACK_MERGE = @as(u32, 268435456);
pub const FLAG_LOOPBACK_REPLACE = @as(u32, 134217728);
pub const FLAG_ASSUME_USER_WQLFILTER_TRUE = @as(u32, 67108864);
pub const FLAG_ASSUME_COMP_WQLFILTER_TRUE = @as(u32, 33554432);
pub const FLAG_PLANNING_MODE = @as(u32, 16777216);
pub const FLAG_NO_USER = @as(u32, 1);
pub const FLAG_NO_COMPUTER = @as(u32, 2);
pub const FLAG_FORCE_CREATENAMESPACE = @as(u32, 4);
pub const RSOP_USER_ACCESS_DENIED = @as(u32, 1);
pub const RSOP_COMPUTER_ACCESS_DENIED = @as(u32, 2);
pub const RSOP_TEMPNAMESPACE_EXISTS = @as(u32, 4);
pub const LOCALSTATE_ASSIGNED = @as(u32, 1);
pub const LOCALSTATE_PUBLISHED = @as(u32, 2);
pub const LOCALSTATE_UNINSTALL_UNMANAGED = @as(u32, 4);
pub const LOCALSTATE_POLICYREMOVE_ORPHAN = @as(u32, 8);
pub const LOCALSTATE_POLICYREMOVE_UNINSTALL = @as(u32, 16);
pub const LOCALSTATE_ORPHANED = @as(u32, 32);
pub const LOCALSTATE_UNINSTALLED = @as(u32, 64);
pub const MANAGED_APPS_USERAPPLICATIONS = @as(u32, 1);
pub const MANAGED_APPS_FROMCATEGORY = @as(u32, 2);
pub const MANAGED_APPS_INFOLEVEL_DEFAULT = @as(u32, 65536);
pub const MANAGED_APPTYPE_WINDOWSINSTALLER = @as(u32, 1);
pub const MANAGED_APPTYPE_SETUPEXE = @as(u32, 2);
pub const MANAGED_APPTYPE_UNSUPPORTED = @as(u32, 3);
pub const CLSID_GPESnapIn = Guid.initString("8fc0b734-a0e1-11d1-a7d3-0000f87571e3");
pub const NODEID_Machine = Guid.initString("8fc0b737-a0e1-11d1-a7d3-0000f87571e3");
pub const NODEID_MachineSWSettings = Guid.initString("8fc0b73a-a0e1-11d1-a7d3-0000f87571e3");
pub const NODEID_User = Guid.initString("8fc0b738-a0e1-11d1-a7d3-0000f87571e3");
pub const NODEID_UserSWSettings = Guid.initString("8fc0b73c-a0e1-11d1-a7d3-0000f87571e3");
pub const CLSID_GroupPolicyObject = Guid.initString("ea502722-a23d-11d1-a7d3-0000f87571e3");
pub const CLSID_RSOPSnapIn = Guid.initString("6dc3804b-7212-458d-adb0-9a07e2ae1fa2");
pub const NODEID_RSOPMachine = Guid.initString("bd4c1a2e-0b7a-4a62-a6b0-c0577539c97e");
pub const NODEID_RSOPMachineSWSettings = Guid.initString("6a76273e-eb8e-45db-94c5-25663a5f2c1a");
pub const NODEID_RSOPUser = Guid.initString("ab87364f-0cec-4cd8-9bf8-898f34628fb8");
pub const NODEID_RSOPUserSWSettings = Guid.initString("e52c5ce3-fd27-4402-84de-d9a5f2858910");
pub const GPO_SECTION_ROOT = @as(u32, 0);
pub const GPO_SECTION_USER = @as(u32, 1);
pub const GPO_SECTION_MACHINE = @as(u32, 2);
pub const GPO_OPEN_LOAD_REGISTRY = @as(u32, 1);
pub const GPO_OPEN_READ_ONLY = @as(u32, 2);
pub const GPO_OPTION_DISABLE_USER = @as(u32, 1);
pub const GPO_OPTION_DISABLE_MACHINE = @as(u32, 2);
pub const RSOP_INFO_FLAG_DIAGNOSTIC_MODE = @as(u32, 1);
pub const GPO_BROWSE_DISABLENEW = @as(u32, 1);
pub const GPO_BROWSE_NOCOMPUTERS = @as(u32, 2);
pub const GPO_BROWSE_NODSGPOS = @as(u32, 4);
pub const GPO_BROWSE_OPENBUTTON = @as(u32, 8);
pub const GPO_BROWSE_INITTOALL = @as(u32, 16);
pub const GPO_BROWSE_NOUSERGPOS = @as(u32, 32);
pub const GPO_BROWSE_SENDAPPLYONEDIT = @as(u32, 64);

//--------------------------------------------------------------------------------
// Section: Types (109)
//--------------------------------------------------------------------------------
// TODO: this type has a FreeFunc 'LeaveCriticalPolicySection', what can Zig do with this information?
pub const CriticalPolicySectionHandle = isize;

const CLSID_GPM_Value = Guid.initString("f5694708-88fe-4b35-babf-e56162d5fbc8");
pub const CLSID_GPM = &CLSID_GPM_Value;

const CLSID_GPMDomain_Value = Guid.initString("710901be-1050-4cb1-838a-c5cff259e183");
pub const CLSID_GPMDomain = &CLSID_GPMDomain_Value;

const CLSID_GPMSitesContainer_Value = Guid.initString("229f5c42-852c-4b30-945f-c522be9bd386");
pub const CLSID_GPMSitesContainer = &CLSID_GPMSitesContainer_Value;

const CLSID_GPMBackupDir_Value = Guid.initString("fce4a59d-0f21-4afa-b859-e6d0c62cd10c");
pub const CLSID_GPMBackupDir = &CLSID_GPMBackupDir_Value;

const CLSID_GPMSOM_Value = Guid.initString("32d93fac-450e-44cf-829c-8b22ff6bdae1");
pub const CLSID_GPMSOM = &CLSID_GPMSOM_Value;

const CLSID_GPMSearchCriteria_Value = Guid.initString("17aaca26-5ce0-44fa-8cc0-5259e6483566");
pub const CLSID_GPMSearchCriteria = &CLSID_GPMSearchCriteria_Value;

const CLSID_GPMPermission_Value = Guid.initString("5871a40a-e9c0-46ec-913e-944ef9225a94");
pub const CLSID_GPMPermission = &CLSID_GPMPermission_Value;

const CLSID_GPMSecurityInfo_Value = Guid.initString("547a5e8f-9162-4516-a4df-9ddb9686d846");
pub const CLSID_GPMSecurityInfo = &CLSID_GPMSecurityInfo_Value;

const CLSID_GPMBackup_Value = Guid.initString("ed1a54b8-5efa-482a-93c0-8ad86f0d68c3");
pub const CLSID_GPMBackup = &CLSID_GPMBackup_Value;

const CLSID_GPMBackupCollection_Value = Guid.initString("eb8f035b-70db-4a9f-9676-37c25994e9dc");
pub const CLSID_GPMBackupCollection = &CLSID_GPMBackupCollection_Value;

const CLSID_GPMSOMCollection_Value = Guid.initString("24c1f147-3720-4f5b-a9c3-06b4e4f931d2");
pub const CLSID_GPMSOMCollection = &CLSID_GPMSOMCollection_Value;

const CLSID_GPMWMIFilter_Value = Guid.initString("626745d8-0dea-4062-bf60-cfc5b1ca1286");
pub const CLSID_GPMWMIFilter = &CLSID_GPMWMIFilter_Value;

const CLSID_GPMWMIFilterCollection_Value = Guid.initString("74dc6d28-e820-47d6-a0b8-f08d93d7fa33");
pub const CLSID_GPMWMIFilterCollection = &CLSID_GPMWMIFilterCollection_Value;

const CLSID_GPMRSOP_Value = Guid.initString("489b0caf-9ec2-4eb7-91f5-b6f71d43da8c");
pub const CLSID_GPMRSOP = &CLSID_GPMRSOP_Value;

const CLSID_GPMGPO_Value = Guid.initString("d2ce2994-59b5-4064-b581-4d68486a16c4");
pub const CLSID_GPMGPO = &CLSID_GPMGPO_Value;

const CLSID_GPMGPOCollection_Value = Guid.initString("7a057325-832d-4de3-a41f-c780436a4e09");
pub const CLSID_GPMGPOCollection = &CLSID_GPMGPOCollection_Value;

const CLSID_GPMGPOLink_Value = Guid.initString("c1df9880-5303-42c6-8a3c-0488e1bf7364");
pub const CLSID_GPMGPOLink = &CLSID_GPMGPOLink_Value;

const CLSID_GPMGPOLinksCollection_Value = Guid.initString("f6ed581a-49a5-47e2-b771-fd8dc02b6259");
pub const CLSID_GPMGPOLinksCollection = &CLSID_GPMGPOLinksCollection_Value;

const CLSID_GPMAsyncCancel_Value = Guid.initString("372796a9-76ec-479d-ad6c-556318ed5f9d");
pub const CLSID_GPMAsyncCancel = &CLSID_GPMAsyncCancel_Value;

const CLSID_GPMStatusMsgCollection_Value = Guid.initString("2824e4be-4bcc-4cac-9e60-0e3ed7f12496");
pub const CLSID_GPMStatusMsgCollection = &CLSID_GPMStatusMsgCollection_Value;

const CLSID_GPMStatusMessage_Value = Guid.initString("4b77cc94-d255-409b-bc62-370881715a19");
pub const CLSID_GPMStatusMessage = &CLSID_GPMStatusMessage_Value;

const CLSID_GPMTrustee_Value = Guid.initString("c54a700d-19b6-4211-bcb0-e8e2475e471e");
pub const CLSID_GPMTrustee = &CLSID_GPMTrustee_Value;

const CLSID_GPMClientSideExtension_Value = Guid.initString("c1a2e70e-659c-4b1a-940b-f88b0af9c8a4");
pub const CLSID_GPMClientSideExtension = &CLSID_GPMClientSideExtension_Value;

const CLSID_GPMCSECollection_Value = Guid.initString("cf92b828-2d44-4b61-b10a-b327afd42da8");
pub const CLSID_GPMCSECollection = &CLSID_GPMCSECollection_Value;

const CLSID_GPMConstants_Value = Guid.initString("3855e880-cd9e-4d0c-9eaf-1579283a1888");
pub const CLSID_GPMConstants = &CLSID_GPMConstants_Value;

const CLSID_GPMResult_Value = Guid.initString("92101ac0-9287-4206-a3b2-4bdb73d225f6");
pub const CLSID_GPMResult = &CLSID_GPMResult_Value;

const CLSID_GPMMapEntryCollection_Value = Guid.initString("0cf75d5b-a3a1-4c55-b4fe-9e149c41f66d");
pub const CLSID_GPMMapEntryCollection = &CLSID_GPMMapEntryCollection_Value;

const CLSID_GPMMapEntry_Value = Guid.initString("8c975253-5431-4471-b35d-0626c928258a");
pub const CLSID_GPMMapEntry = &CLSID_GPMMapEntry_Value;

const CLSID_GPMMigrationTable_Value = Guid.initString("55af4043-2a06-4f72-abef-631b44079c76");
pub const CLSID_GPMMigrationTable = &CLSID_GPMMigrationTable_Value;

const CLSID_GPMBackupDirEx_Value = Guid.initString("e8c0988a-cf03-4c5b-8be2-2aa9ad32aada");
pub const CLSID_GPMBackupDirEx = &CLSID_GPMBackupDirEx_Value;

const CLSID_GPMStarterGPOBackupCollection_Value = Guid.initString("e75ea59d-1aeb-4cb5-a78a-281daa582406");
pub const CLSID_GPMStarterGPOBackupCollection = &CLSID_GPMStarterGPOBackupCollection_Value;

const CLSID_GPMStarterGPOBackup_Value = Guid.initString("389e400a-d8ef-455b-a861-5f9ca34a6a02");
pub const CLSID_GPMStarterGPOBackup = &CLSID_GPMStarterGPOBackup_Value;

const CLSID_GPMTemplate_Value = Guid.initString("ecf1d454-71da-4e2f-a8c0-8185465911d9");
pub const CLSID_GPMTemplate = &CLSID_GPMTemplate_Value;

const CLSID_GPMStarterGPOCollection_Value = Guid.initString("82f8aa8b-49ba-43b2-956e-3397f9b94c3a");
pub const CLSID_GPMStarterGPOCollection = &CLSID_GPMStarterGPOCollection_Value;

pub const GPMRSOPMode = enum(i32) {
    Unknown = 0,
    Planning = 1,
    Logging = 2,
};
pub const rsopUnknown = GPMRSOPMode.Unknown;
pub const rsopPlanning = GPMRSOPMode.Planning;
pub const rsopLogging = GPMRSOPMode.Logging;

pub const GPMPermissionType = enum(i32) {
    GPOApply = 65536,
    GPORead = 65792,
    GPOEdit = 65793,
    GPOEditSecurityAndDelete = 65794,
    GPOCustom = 65795,
    WMIFilterEdit = 131072,
    WMIFilterFullControl = 131073,
    WMIFilterCustom = 131074,
    SOMLink = 1835008,
    SOMLogging = 1573120,
    SOMPlanning = 1573376,
    SOMWMICreate = 1049344,
    SOMWMIFullControl = 1049345,
    SOMGPOCreate = 1049600,
    StarterGPORead = 197888,
    StarterGPOEdit = 197889,
    StarterGPOFullControl = 197890,
    StarterGPOCustom = 197891,
    SOMStarterGPOCreate = 1049856,
};
pub const permGPOApply = GPMPermissionType.GPOApply;
pub const permGPORead = GPMPermissionType.GPORead;
pub const permGPOEdit = GPMPermissionType.GPOEdit;
pub const permGPOEditSecurityAndDelete = GPMPermissionType.GPOEditSecurityAndDelete;
pub const permGPOCustom = GPMPermissionType.GPOCustom;
pub const permWMIFilterEdit = GPMPermissionType.WMIFilterEdit;
pub const permWMIFilterFullControl = GPMPermissionType.WMIFilterFullControl;
pub const permWMIFilterCustom = GPMPermissionType.WMIFilterCustom;
pub const permSOMLink = GPMPermissionType.SOMLink;
pub const permSOMLogging = GPMPermissionType.SOMLogging;
pub const permSOMPlanning = GPMPermissionType.SOMPlanning;
pub const permSOMWMICreate = GPMPermissionType.SOMWMICreate;
pub const permSOMWMIFullControl = GPMPermissionType.SOMWMIFullControl;
pub const permSOMGPOCreate = GPMPermissionType.SOMGPOCreate;
pub const permStarterGPORead = GPMPermissionType.StarterGPORead;
pub const permStarterGPOEdit = GPMPermissionType.StarterGPOEdit;
pub const permStarterGPOFullControl = GPMPermissionType.StarterGPOFullControl;
pub const permStarterGPOCustom = GPMPermissionType.StarterGPOCustom;
pub const permSOMStarterGPOCreate = GPMPermissionType.SOMStarterGPOCreate;

pub const GPMSearchProperty = enum(i32) {
    gpoPermissions = 0,
    gpoEffectivePermissions = 1,
    gpoDisplayName = 2,
    gpoWMIFilter = 3,
    gpoID = 4,
    gpoComputerExtensions = 5,
    gpoUserExtensions = 6,
    somLinks = 7,
    gpoDomain = 8,
    backupMostRecent = 9,
    starterGPOPermissions = 10,
    starterGPOEffectivePermissions = 11,
    starterGPODisplayName = 12,
    starterGPOID = 13,
    starterGPODomain = 14,
};
pub const gpoPermissions = GPMSearchProperty.gpoPermissions;
pub const gpoEffectivePermissions = GPMSearchProperty.gpoEffectivePermissions;
pub const gpoDisplayName = GPMSearchProperty.gpoDisplayName;
pub const gpoWMIFilter = GPMSearchProperty.gpoWMIFilter;
pub const gpoID = GPMSearchProperty.gpoID;
pub const gpoComputerExtensions = GPMSearchProperty.gpoComputerExtensions;
pub const gpoUserExtensions = GPMSearchProperty.gpoUserExtensions;
pub const somLinks = GPMSearchProperty.somLinks;
pub const gpoDomain = GPMSearchProperty.gpoDomain;
pub const backupMostRecent = GPMSearchProperty.backupMostRecent;
pub const starterGPOPermissions = GPMSearchProperty.starterGPOPermissions;
pub const starterGPOEffectivePermissions = GPMSearchProperty.starterGPOEffectivePermissions;
pub const starterGPODisplayName = GPMSearchProperty.starterGPODisplayName;
pub const starterGPOID = GPMSearchProperty.starterGPOID;
pub const starterGPODomain = GPMSearchProperty.starterGPODomain;

pub const GPMSearchOperation = enum(i32) {
    Equals = 0,
    Contains = 1,
    NotContains = 2,
    NotEquals = 3,
};
pub const opEquals = GPMSearchOperation.Equals;
pub const opContains = GPMSearchOperation.Contains;
pub const opNotContains = GPMSearchOperation.NotContains;
pub const opNotEquals = GPMSearchOperation.NotEquals;

pub const GPMReportType = enum(i32) {
    XML = 0,
    HTML = 1,
    InfraXML = 2,
    InfraRefreshXML = 3,
    ClientHealthXML = 4,
    ClientHealthRefreshXML = 5,
};
pub const repXML = GPMReportType.XML;
pub const repHTML = GPMReportType.HTML;
pub const repInfraXML = GPMReportType.InfraXML;
pub const repInfraRefreshXML = GPMReportType.InfraRefreshXML;
pub const repClientHealthXML = GPMReportType.ClientHealthXML;
pub const repClientHealthRefreshXML = GPMReportType.ClientHealthRefreshXML;

pub const GPMEntryType = enum(i32) {
    User = 0,
    Computer = 1,
    LocalGroup = 2,
    GlobalGroup = 3,
    UniversalGroup = 4,
    UNCPath = 5,
    Unknown = 6,
};
pub const typeUser = GPMEntryType.User;
pub const typeComputer = GPMEntryType.Computer;
pub const typeLocalGroup = GPMEntryType.LocalGroup;
pub const typeGlobalGroup = GPMEntryType.GlobalGroup;
pub const typeUniversalGroup = GPMEntryType.UniversalGroup;
pub const typeUNCPath = GPMEntryType.UNCPath;
pub const typeUnknown = GPMEntryType.Unknown;

pub const GPMDestinationOption = enum(i32) {
    SameAsSource = 0,
    None = 1,
    ByRelativeName = 2,
    Set = 3,
};
pub const opDestinationSameAsSource = GPMDestinationOption.SameAsSource;
pub const opDestinationNone = GPMDestinationOption.None;
pub const opDestinationByRelativeName = GPMDestinationOption.ByRelativeName;
pub const opDestinationSet = GPMDestinationOption.Set;

pub const GPMReportingOptions = enum(i32) {
    Legacy = 0,
    Comments = 1,
};
pub const opReportLegacy = GPMReportingOptions.Legacy;
pub const opReportComments = GPMReportingOptions.Comments;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPM_Value = Guid.initString("f5fae809-3bd6-4da9-a65e-17665b41d763");
pub const IID_IGPM = &IID_IGPM_Value;
pub const IGPM = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetDomain: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrDomain: ?BSTR,
                bstrDomainController: ?BSTR,
                lDCFlags: i32,
                pIGPMDomain: ?*?*IGPMDomain,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrDomain: ?BSTR,
                bstrDomainController: ?BSTR,
                lDCFlags: i32,
                pIGPMDomain: ?*?*IGPMDomain,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupDir: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrBackupDir: ?BSTR,
                pIGPMBackupDir: ?*?*IGPMBackupDir,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrBackupDir: ?BSTR,
                pIGPMBackupDir: ?*?*IGPMBackupDir,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSitesContainer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrForest: ?BSTR,
                bstrDomain: ?BSTR,
                bstrDomainController: ?BSTR,
                lDCFlags: i32,
                ppIGPMSitesContainer: ?*?*IGPMSitesContainer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrForest: ?BSTR,
                bstrDomain: ?BSTR,
                bstrDomainController: ?BSTR,
                lDCFlags: i32,
                ppIGPMSitesContainer: ?*?*IGPMSitesContainer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRSOP: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                gpmRSoPMode: GPMRSOPMode,
                bstrNamespace: ?BSTR,
                lFlags: i32,
                ppIGPMRSOP: ?*?*IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                gpmRSoPMode: GPMRSOPMode,
                bstrNamespace: ?BSTR,
                lFlags: i32,
                ppIGPMRSOP: ?*?*IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreatePermission: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrTrustee: ?BSTR,
                perm: GPMPermissionType,
                bInheritable: i16,
                ppPerm: ?*?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrTrustee: ?BSTR,
                perm: GPMPermissionType,
                bInheritable: i16,
                ppPerm: ?*?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateSearchCriteria: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                ppIGPMSearchCriteria: ?*?*IGPMSearchCriteria,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                ppIGPMSearchCriteria: ?*?*IGPMSearchCriteria,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateTrustee: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrTrustee: ?BSTR,
                ppIGPMTrustee: ?*?*IGPMTrustee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrTrustee: ?BSTR,
                ppIGPMTrustee: ?*?*IGPMTrustee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetClientSideExtensions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                ppIGPMCSECollection: ?*?*IGPMCSECollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                ppIGPMCSECollection: ?*?*IGPMCSECollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetConstants: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                ppIGPMConstants: ?*?*IGPMConstants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                ppIGPMConstants: ?*?*IGPMConstants,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMigrationTable: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrMigrationTablePath: ?BSTR,
                ppMigrationTable: ?*?*IGPMMigrationTable,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrMigrationTablePath: ?BSTR,
                ppMigrationTable: ?*?*IGPMMigrationTable,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateMigrationTable: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                ppMigrationTable: ?*?*IGPMMigrationTable,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                ppMigrationTable: ?*?*IGPMMigrationTable,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InitializeReporting: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM,
                bstrAdmPath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM,
                bstrAdmPath: ?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 IGPM_GetDomain(self: *const T, bstrDomain: ?BSTR, bstrDomainController: ?BSTR, lDCFlags: i32, pIGPMDomain: ?*?*IGPMDomain) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetDomain(@as(*const IGPM, @ptrCast(self)), bstrDomain, bstrDomainController, lDCFlags, pIGPMDomain);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetBackupDir(self: *const T, bstrBackupDir: ?BSTR, pIGPMBackupDir: ?*?*IGPMBackupDir) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetBackupDir(@as(*const IGPM, @ptrCast(self)), bstrBackupDir, pIGPMBackupDir);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetSitesContainer(self: *const T, bstrForest: ?BSTR, bstrDomain: ?BSTR, bstrDomainController: ?BSTR, lDCFlags: i32, ppIGPMSitesContainer: ?*?*IGPMSitesContainer) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetSitesContainer(@as(*const IGPM, @ptrCast(self)), bstrForest, bstrDomain, bstrDomainController, lDCFlags, ppIGPMSitesContainer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetRSOP(self: *const T, gpmRSoPMode: GPMRSOPMode, bstrNamespace: ?BSTR, lFlags: i32, ppIGPMRSOP: ?*?*IGPMRSOP) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetRSOP(@as(*const IGPM, @ptrCast(self)), gpmRSoPMode, bstrNamespace, lFlags, ppIGPMRSOP);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_CreatePermission(self: *const T, bstrTrustee: ?BSTR, perm: GPMPermissionType, bInheritable: i16, ppPerm: ?*?*IGPMPermission) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).CreatePermission(@as(*const IGPM, @ptrCast(self)), bstrTrustee, perm, bInheritable, ppPerm);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_CreateSearchCriteria(self: *const T, ppIGPMSearchCriteria: ?*?*IGPMSearchCriteria) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).CreateSearchCriteria(@as(*const IGPM, @ptrCast(self)), ppIGPMSearchCriteria);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_CreateTrustee(self: *const T, bstrTrustee: ?BSTR, ppIGPMTrustee: ?*?*IGPMTrustee) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).CreateTrustee(@as(*const IGPM, @ptrCast(self)), bstrTrustee, ppIGPMTrustee);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetClientSideExtensions(self: *const T, ppIGPMCSECollection: ?*?*IGPMCSECollection) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetClientSideExtensions(@as(*const IGPM, @ptrCast(self)), ppIGPMCSECollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetConstants(self: *const T, ppIGPMConstants: ?*?*IGPMConstants) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetConstants(@as(*const IGPM, @ptrCast(self)), ppIGPMConstants);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_GetMigrationTable(self: *const T, bstrMigrationTablePath: ?BSTR, ppMigrationTable: ?*?*IGPMMigrationTable) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).GetMigrationTable(@as(*const IGPM, @ptrCast(self)), bstrMigrationTablePath, ppMigrationTable);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_CreateMigrationTable(self: *const T, ppMigrationTable: ?*?*IGPMMigrationTable) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).CreateMigrationTable(@as(*const IGPM, @ptrCast(self)), ppMigrationTable);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM_InitializeReporting(self: *const T, bstrAdmPath: ?BSTR) HRESULT {
                return @as(*const IGPM.VTable, @ptrCast(self.vtable)).InitializeReporting(@as(*const IGPM, @ptrCast(self)), bstrAdmPath);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMDomain_Value = Guid.initString("6b21cc14-5a00-4f44-a738-feec8a94c7e3");
pub const IID_IGPMDomain = &IID_IGPMDomain_Value;
pub const IGPMDomain = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DomainController: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMDomain,
                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 IGPMDomain,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Domain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMDomain,
                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 IGPMDomain,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                ppNewGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                ppNewGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                bstrGuid: ?BSTR,
                ppGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                bstrGuid: ?BSTR,
                ppGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchGPOs: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMGPOCollection: ?*?*IGPMGPOCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMGPOCollection: ?*?*IGPMGPOCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RestoreGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                pIGPMBackup: ?*IGPMBackup,
                lDCFlags: i32,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                pIGPMBackup: ?*IGPMBackup,
                lDCFlags: i32,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSOM: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                bstrPath: ?BSTR,
                ppSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                bstrPath: ?BSTR,
                ppSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchSOMs: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMSOMCollection: ?*?*IGPMSOMCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMSOMCollection: ?*?*IGPMSOMCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetWMIFilter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                bstrPath: ?BSTR,
                ppWMIFilter: ?*?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                bstrPath: ?BSTR,
                ppWMIFilter: ?*?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchWMIFilters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMWMIFilterCollection: ?*?*IGPMWMIFilterCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMWMIFilterCollection: ?*?*IGPMWMIFilterCollection,
            ) 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 IGPMDomain_get_DomainController(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).get_DomainController(@as(*const IGPMDomain, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_get_Domain(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).get_Domain(@as(*const IGPMDomain, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_CreateGPO(self: *const T, ppNewGPO: ?*?*IGPMGPO) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).CreateGPO(@as(*const IGPMDomain, @ptrCast(self)), ppNewGPO);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_GetGPO(self: *const T, bstrGuid: ?BSTR, ppGPO: ?*?*IGPMGPO) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).GetGPO(@as(*const IGPMDomain, @ptrCast(self)), bstrGuid, ppGPO);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_SearchGPOs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMGPOCollection: ?*?*IGPMGPOCollection) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).SearchGPOs(@as(*const IGPMDomain, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMGPOCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_RestoreGPO(self: *const T, pIGPMBackup: ?*IGPMBackup, lDCFlags: i32, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).RestoreGPO(@as(*const IGPMDomain, @ptrCast(self)), pIGPMBackup, lDCFlags, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_GetSOM(self: *const T, bstrPath: ?BSTR, ppSOM: ?*?*IGPMSOM) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).GetSOM(@as(*const IGPMDomain, @ptrCast(self)), bstrPath, ppSOM);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_SearchSOMs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMSOMCollection: ?*?*IGPMSOMCollection) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).SearchSOMs(@as(*const IGPMDomain, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMSOMCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_GetWMIFilter(self: *const T, bstrPath: ?BSTR, ppWMIFilter: ?*?*IGPMWMIFilter) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).GetWMIFilter(@as(*const IGPMDomain, @ptrCast(self)), bstrPath, ppWMIFilter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain_SearchWMIFilters(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMWMIFilterCollection: ?*?*IGPMWMIFilterCollection) HRESULT {
                return @as(*const IGPMDomain.VTable, @ptrCast(self.vtable)).SearchWMIFilters(@as(*const IGPMDomain, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMWMIFilterCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMBackupDir_Value = Guid.initString("b1568bed-0a93-4acc-810f-afe7081019b9");
pub const IID_IGPMBackupDir = &IID_IGPMBackupDir_Value;
pub const IGPMBackupDir = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupDirectory: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupDir,
                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 IGPMBackupDir,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackupDir,
                bstrID: ?BSTR,
                ppBackup: ?*?*IGPMBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackupDir,
                bstrID: ?BSTR,
                ppBackup: ?*?*IGPMBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchBackups: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackupDir,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMBackupCollection: ?*?*IGPMBackupCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackupDir,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMBackupCollection: ?*?*IGPMBackupCollection,
            ) 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 IGPMBackupDir_get_BackupDirectory(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackupDir.VTable, @ptrCast(self.vtable)).get_BackupDirectory(@as(*const IGPMBackupDir, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupDir_GetBackup(self: *const T, bstrID: ?BSTR, ppBackup: ?*?*IGPMBackup) HRESULT {
                return @as(*const IGPMBackupDir.VTable, @ptrCast(self.vtable)).GetBackup(@as(*const IGPMBackupDir, @ptrCast(self)), bstrID, ppBackup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupDir_SearchBackups(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMBackupCollection: ?*?*IGPMBackupCollection) HRESULT {
                return @as(*const IGPMBackupDir.VTable, @ptrCast(self.vtable)).SearchBackups(@as(*const IGPMBackupDir, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMBackupCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMSitesContainer_Value = Guid.initString("4725a899-2782-4d27-a6bb-d499246ffd72");
pub const IID_IGPMSitesContainer = &IID_IGPMSitesContainer_Value;
pub const IGPMSitesContainer = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DomainController: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSitesContainer,
                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 IGPMSitesContainer,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Domain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSitesContainer,
                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 IGPMSitesContainer,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Forest: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSitesContainer,
                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 IGPMSitesContainer,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSite: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSitesContainer,
                bstrSiteName: ?BSTR,
                ppSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSitesContainer,
                bstrSiteName: ?BSTR,
                ppSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchSites: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSitesContainer,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMSOMCollection: ?*?*IGPMSOMCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSitesContainer,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMSOMCollection: ?*?*IGPMSOMCollection,
            ) 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 IGPMSitesContainer_get_DomainController(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMSitesContainer.VTable, @ptrCast(self.vtable)).get_DomainController(@as(*const IGPMSitesContainer, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSitesContainer_get_Domain(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMSitesContainer.VTable, @ptrCast(self.vtable)).get_Domain(@as(*const IGPMSitesContainer, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSitesContainer_get_Forest(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMSitesContainer.VTable, @ptrCast(self.vtable)).get_Forest(@as(*const IGPMSitesContainer, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSitesContainer_GetSite(self: *const T, bstrSiteName: ?BSTR, ppSOM: ?*?*IGPMSOM) HRESULT {
                return @as(*const IGPMSitesContainer.VTable, @ptrCast(self.vtable)).GetSite(@as(*const IGPMSitesContainer, @ptrCast(self)), bstrSiteName, ppSOM);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSitesContainer_SearchSites(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMSOMCollection: ?*?*IGPMSOMCollection) HRESULT {
                return @as(*const IGPMSitesContainer.VTable, @ptrCast(self.vtable)).SearchSites(@as(*const IGPMSitesContainer, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMSOMCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMSearchCriteria_Value = Guid.initString("d6f11c42-829b-48d4-83f5-3615b67dfc22");
pub const IID_IGPMSearchCriteria = &IID_IGPMSearchCriteria_Value;
pub const IGPMSearchCriteria = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSearchCriteria,
                searchProperty: GPMSearchProperty,
                searchOperation: GPMSearchOperation,
                varValue: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSearchCriteria,
                searchProperty: GPMSearchProperty,
                searchOperation: GPMSearchOperation,
                varValue: 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 IGPMSearchCriteria_Add(self: *const T, searchProperty: GPMSearchProperty, searchOperation: GPMSearchOperation, varValue: VARIANT) HRESULT {
                return @as(*const IGPMSearchCriteria.VTable, @ptrCast(self.vtable)).Add(@as(*const IGPMSearchCriteria, @ptrCast(self)), searchProperty, searchOperation, varValue);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMTrustee_Value = Guid.initString("3b466da8-c1a4-4b2a-999a-befcdd56cefb");
pub const IID_IGPMTrustee = &IID_IGPMTrustee_Value;
pub const IGPMTrustee = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TrusteeSid: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMTrustee,
                bstrVal: ?*?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 IGPMTrustee,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TrusteeName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMTrustee,
                bstrVal: ?*?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 IGPMTrustee,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TrusteeDomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMTrustee,
                bstrVal: ?*?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 IGPMTrustee,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TrusteeDSPath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMTrustee,
                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 IGPMTrustee,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_TrusteeType: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMTrustee,
                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 IGPMTrustee,
                lVal: ?*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 IGPMTrustee_get_TrusteeSid(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMTrustee.VTable, @ptrCast(self.vtable)).get_TrusteeSid(@as(*const IGPMTrustee, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMTrustee_get_TrusteeName(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMTrustee.VTable, @ptrCast(self.vtable)).get_TrusteeName(@as(*const IGPMTrustee, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMTrustee_get_TrusteeDomain(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMTrustee.VTable, @ptrCast(self.vtable)).get_TrusteeDomain(@as(*const IGPMTrustee, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMTrustee_get_TrusteeDSPath(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMTrustee.VTable, @ptrCast(self.vtable)).get_TrusteeDSPath(@as(*const IGPMTrustee, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMTrustee_get_TrusteeType(self: *const T, lVal: ?*i32) HRESULT {
                return @as(*const IGPMTrustee.VTable, @ptrCast(self.vtable)).get_TrusteeType(@as(*const IGPMTrustee, @ptrCast(self)), lVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMPermission_Value = Guid.initString("35ebca40-e1a1-4a02-8905-d79416fb464a");
pub const IID_IGPMPermission = &IID_IGPMPermission_Value;
pub const IGPMPermission = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Inherited: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Inheritable: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Denied: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMPermission,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Permission: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMPermission,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMPermission,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Trustee: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMPermission,
                ppIGPMTrustee: ?*?*IGPMTrustee,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMPermission,
                ppIGPMTrustee: ?*?*IGPMTrustee,
            ) 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 IGPMPermission_get_Inherited(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMPermission.VTable, @ptrCast(self.vtable)).get_Inherited(@as(*const IGPMPermission, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMPermission_get_Inheritable(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMPermission.VTable, @ptrCast(self.vtable)).get_Inheritable(@as(*const IGPMPermission, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMPermission_get_Denied(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMPermission.VTable, @ptrCast(self.vtable)).get_Denied(@as(*const IGPMPermission, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMPermission_get_Permission(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMPermission.VTable, @ptrCast(self.vtable)).get_Permission(@as(*const IGPMPermission, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMPermission_get_Trustee(self: *const T, ppIGPMTrustee: ?*?*IGPMTrustee) HRESULT {
                return @as(*const IGPMPermission.VTable, @ptrCast(self.vtable)).get_Trustee(@as(*const IGPMPermission, @ptrCast(self)), ppIGPMTrustee);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMSecurityInfo_Value = Guid.initString("b6c31ed4-1c93-4d3e-ae84-eb6d61161b60");
pub const IID_IGPMSecurityInfo = &IID_IGPMSecurityInfo_Value;
pub const IGPMSecurityInfo = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                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 IGPMSecurityInfo,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                lIndex: i32,
                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 IGPMSecurityInfo,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                ppEnum: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMSecurityInfo,
                ppEnum: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                pPerm: ?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSecurityInfo,
                pPerm: ?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Remove: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                pPerm: ?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSecurityInfo,
                pPerm: ?*IGPMPermission,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveTrustee: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSecurityInfo,
                bstrTrustee: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSecurityInfo,
                bstrTrustee: ?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 IGPMSecurityInfo_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMSecurityInfo, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSecurityInfo_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMSecurityInfo, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSecurityInfo_get__NewEnum(self: *const T, ppEnum: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMSecurityInfo, @ptrCast(self)), ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSecurityInfo_Add(self: *const T, pPerm: ?*IGPMPermission) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).Add(@as(*const IGPMSecurityInfo, @ptrCast(self)), pPerm);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSecurityInfo_Remove(self: *const T, pPerm: ?*IGPMPermission) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).Remove(@as(*const IGPMSecurityInfo, @ptrCast(self)), pPerm);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSecurityInfo_RemoveTrustee(self: *const T, bstrTrustee: ?BSTR) HRESULT {
                return @as(*const IGPMSecurityInfo.VTable, @ptrCast(self.vtable)).RemoveTrustee(@as(*const IGPMSecurityInfo, @ptrCast(self)), bstrTrustee);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMBackup_Value = Guid.initString("d8a16a35-3b0d-416b-8d02-4df6f95a7119");
pub const IID_IGPMBackup = &IID_IGPMBackup_Value;
pub const IGPMBackup = 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 IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPOID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPODomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPODisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Timestamp: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                pVal: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMBackup,
                pVal: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Comment: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupDir: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackup,
                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 IGPMBackup,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackup,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackup,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReportToFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackup,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackup,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) 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 IGPMBackup_get_ID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_ID(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_GPOID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_GPOID(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_GPODomain(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_GPODomain(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_GPODisplayName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_GPODisplayName(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_Timestamp(self: *const T, pVal: ?*f64) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_Timestamp(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_Comment(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_Comment(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_get_BackupDir(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).get_BackupDir(@as(*const IGPMBackup, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_Delete(self: *const T) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGPMBackup, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMBackup, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackup_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMBackup.VTable, @ptrCast(self.vtable)).GenerateReportToFile(@as(*const IGPMBackup, @ptrCast(self)), gpmReportType, bstrTargetFilePath, ppIGPMResult);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMBackupCollection_Value = Guid.initString("c786fc0f-26d8-4bab-a745-39ca7e800cac");
pub const IID_IGPMBackupCollection = &IID_IGPMBackupCollection_Value;
pub const IGPMBackupCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupCollection,
                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 IGPMBackupCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupCollection,
                lIndex: i32,
                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 IGPMBackupCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupCollection,
                ppIGPMBackup: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMBackupCollection,
                ppIGPMBackup: ?*?*IEnumVARIANT,
            ) 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 IGPMBackupCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMBackupCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMBackupCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMBackupCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMBackupCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupCollection_get__NewEnum(self: *const T, ppIGPMBackup: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMBackupCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMBackupCollection, @ptrCast(self)), ppIGPMBackup);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const GPMSOMType = enum(i32) {
    Site = 0,
    Domain = 1,
    OU = 2,
};
pub const somSite = GPMSOMType.Site;
pub const somDomain = GPMSOMType.Domain;
pub const somOU = GPMSOMType.OU;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMSOM_Value = Guid.initString("c0a7f09e-05a1-4f0c-8158-9e5c33684f6b");
pub const IID_IGPMSOM = &IID_IGPMSOM_Value;
pub const IGPMSOM = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPOInheritanceBlocked: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOM,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMSOM,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_GPOInheritanceBlocked: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOM,
                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 IGPMSOM,
                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 IGPMSOM,
                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 IGPMSOM,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Path: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOM,
                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 IGPMSOM,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateGPOLink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSOM,
                lLinkPos: i32,
                pGPO: ?*IGPMGPO,
                ppNewGPOLink: ?*?*IGPMGPOLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSOM,
                lLinkPos: i32,
                pGPO: ?*IGPMGPO,
                ppNewGPOLink: ?*?*IGPMGPOLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Type: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOM,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMSOM,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetGPOLinks: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSOM,
                ppGPOLinks: ?*?*IGPMGPOLinksCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSOM,
                ppGPOLinks: ?*?*IGPMGPOLinksCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetInheritedGPOLinks: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSOM,
                ppGPOLinks: ?*?*IGPMGPOLinksCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSOM,
                ppGPOLinks: ?*?*IGPMGPOLinksCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSOM,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSOM,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMSOM,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMSOM,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) 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 IGPMSOM_get_GPOInheritanceBlocked(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).get_GPOInheritanceBlocked(@as(*const IGPMSOM, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_put_GPOInheritanceBlocked(self: *const T, newVal: i16) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).put_GPOInheritanceBlocked(@as(*const IGPMSOM, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_get_Name(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IGPMSOM, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_get_Path(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).get_Path(@as(*const IGPMSOM, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_CreateGPOLink(self: *const T, lLinkPos: i32, pGPO: ?*IGPMGPO, ppNewGPOLink: ?*?*IGPMGPOLink) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).CreateGPOLink(@as(*const IGPMSOM, @ptrCast(self)), lLinkPos, pGPO, ppNewGPOLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_get_Type(self: *const T, pVal: ?*GPMSOMType) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).get_Type(@as(*const IGPMSOM, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_GetGPOLinks(self: *const T, ppGPOLinks: ?*?*IGPMGPOLinksCollection) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).GetGPOLinks(@as(*const IGPMSOM, @ptrCast(self)), ppGPOLinks);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_GetInheritedGPOLinks(self: *const T, ppGPOLinks: ?*?*IGPMGPOLinksCollection) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).GetInheritedGPOLinks(@as(*const IGPMSOM, @ptrCast(self)), ppGPOLinks);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).GetSecurityInfo(@as(*const IGPMSOM, @ptrCast(self)), ppSecurityInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOM_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMSOM.VTable, @ptrCast(self.vtable)).SetSecurityInfo(@as(*const IGPMSOM, @ptrCast(self)), pSecurityInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMSOMCollection_Value = Guid.initString("adc1688e-00e4-4495-abba-bed200df0cab");
pub const IID_IGPMSOMCollection = &IID_IGPMSOMCollection_Value;
pub const IGPMSOMCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOMCollection,
                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 IGPMSOMCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOMCollection,
                lIndex: i32,
                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 IGPMSOMCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMSOMCollection,
                ppIGPMSOM: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMSOMCollection,
                ppIGPMSOM: ?*?*IEnumVARIANT,
            ) 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 IGPMSOMCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMSOMCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMSOMCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOMCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMSOMCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMSOMCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMSOMCollection_get__NewEnum(self: *const T, ppIGPMSOM: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMSOMCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMSOMCollection, @ptrCast(self)), ppIGPMSOM);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMWMIFilter_Value = Guid.initString("ef2ff9b4-3c27-459a-b979-038305cec75d");
pub const IID_IGPMWMIFilter = &IID_IGPMWMIFilter_Value;
pub const IGPMWMIFilter = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Path: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                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 IGPMWMIFilter,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMWMIFilter,
                newVal: ?BSTR,
            ) 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 IGPMWMIFilter,
                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 IGPMWMIFilter,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMWMIFilter,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                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 IGPMWMIFilter,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetQueryList: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                pQryList: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMWMIFilter,
                pQryList: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMWMIFilter,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMWMIFilter,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMWMIFilter,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) 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 IGPMWMIFilter_get_Path(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).get_Path(@as(*const IGPMWMIFilter, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_put_Name(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).put_Name(@as(*const IGPMWMIFilter, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_get_Name(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IGPMWMIFilter, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_put_Description(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).put_Description(@as(*const IGPMWMIFilter, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_get_Description(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).get_Description(@as(*const IGPMWMIFilter, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_GetQueryList(self: *const T, pQryList: ?*VARIANT) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).GetQueryList(@as(*const IGPMWMIFilter, @ptrCast(self)), pQryList);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).GetSecurityInfo(@as(*const IGPMWMIFilter, @ptrCast(self)), ppSecurityInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilter_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMWMIFilter.VTable, @ptrCast(self.vtable)).SetSecurityInfo(@as(*const IGPMWMIFilter, @ptrCast(self)), pSecurityInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMWMIFilterCollection_Value = Guid.initString("5782d582-1a36-4661-8a94-c3c32551945b");
pub const IID_IGPMWMIFilterCollection = &IID_IGPMWMIFilterCollection_Value;
pub const IGPMWMIFilterCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilterCollection,
                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 IGPMWMIFilterCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilterCollection,
                lIndex: i32,
                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 IGPMWMIFilterCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMWMIFilterCollection,
                pVal: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMWMIFilterCollection,
                pVal: ?*?*IEnumVARIANT,
            ) 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 IGPMWMIFilterCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMWMIFilterCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMWMIFilterCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilterCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMWMIFilterCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMWMIFilterCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMWMIFilterCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMWMIFilterCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMWMIFilterCollection, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMRSOP_Value = Guid.initString("49ed785a-3237-4ff2-b1f0-fdf5a8d5a1ee");
pub const IID_IGPMRSOP = &IID_IGPMRSOP_Value;
pub const IGPMRSOP = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Mode: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMRSOP,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Namespace: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_LoggingComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LoggingComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_LoggingUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LoggingUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_LoggingFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                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 IGPMRSOP,
                lVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LoggingFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                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 IGPMRSOP,
                lVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                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 IGPMRSOP,
                lVal: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                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 IGPMRSOP,
                lVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningDomainController: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningDomainController: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningSiteName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningSiteName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningUserSOM: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningUserSOM: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningUserWMIFilters: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: 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 IGPMRSOP,
                varVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningUserWMIFilters: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: ?*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 IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningUserSecurityGroups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: 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 IGPMRSOP,
                varVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningUserSecurityGroups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: ?*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 IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningComputerSOM: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?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 IGPMRSOP,
                bstrVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningComputerSOM: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                bstrVal: ?*?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 IGPMRSOP,
                bstrVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningComputerWMIFilters: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: 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 IGPMRSOP,
                varVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningComputerWMIFilters: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: ?*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 IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_PlanningComputerSecurityGroups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: 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 IGPMRSOP,
                varVal: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PlanningComputerSecurityGroups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: ?*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 IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        LoggingEnumerateUsers: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMRSOP,
                varVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateQueryResults: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReleaseQueryResults: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMRSOP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMRSOP,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMRSOP,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReportToFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMRSOP,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMRSOP,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) 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 IGPMRSOP_get_Mode(self: *const T, pVal: ?*GPMRSOPMode) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_Mode(@as(*const IGPMRSOP, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_Namespace(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_Namespace(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_LoggingComputer(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_LoggingComputer(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_LoggingComputer(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_LoggingComputer(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_LoggingUser(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_LoggingUser(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_LoggingUser(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_LoggingUser(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_LoggingFlags(self: *const T, lVal: i32) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_LoggingFlags(@as(*const IGPMRSOP, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_LoggingFlags(self: *const T, lVal: ?*i32) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_LoggingFlags(@as(*const IGPMRSOP, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningFlags(self: *const T, lVal: i32) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningFlags(@as(*const IGPMRSOP, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningFlags(self: *const T, lVal: ?*i32) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningFlags(@as(*const IGPMRSOP, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningDomainController(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningDomainController(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningDomainController(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningDomainController(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningSiteName(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningSiteName(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningSiteName(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningSiteName(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningUser(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningUser(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningUser(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningUser(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningUserSOM(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningUserSOM(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningUserSOM(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningUserSOM(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningUserWMIFilters(self: *const T, varVal: VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningUserWMIFilters(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningUserWMIFilters(self: *const T, varVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningUserWMIFilters(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningUserSecurityGroups(self: *const T, varVal: VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningUserSecurityGroups(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningUserSecurityGroups(self: *const T, varVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningUserSecurityGroups(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningComputer(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningComputer(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningComputer(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningComputer(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningComputerSOM(self: *const T, bstrVal: ?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningComputerSOM(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningComputerSOM(self: *const T, bstrVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningComputerSOM(@as(*const IGPMRSOP, @ptrCast(self)), bstrVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningComputerWMIFilters(self: *const T, varVal: VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningComputerWMIFilters(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningComputerWMIFilters(self: *const T, varVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningComputerWMIFilters(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_put_PlanningComputerSecurityGroups(self: *const T, varVal: VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).put_PlanningComputerSecurityGroups(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_get_PlanningComputerSecurityGroups(self: *const T, varVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).get_PlanningComputerSecurityGroups(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_LoggingEnumerateUsers(self: *const T, varVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).LoggingEnumerateUsers(@as(*const IGPMRSOP, @ptrCast(self)), varVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_CreateQueryResults(self: *const T) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).CreateQueryResults(@as(*const IGPMRSOP, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_ReleaseQueryResults(self: *const T) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).ReleaseQueryResults(@as(*const IGPMRSOP, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMRSOP, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMRSOP_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMRSOP.VTable, @ptrCast(self.vtable)).GenerateReportToFile(@as(*const IGPMRSOP, @ptrCast(self)), gpmReportType, bstrTargetFilePath, ppIGPMResult);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMGPO_Value = Guid.initString("58cc4352-1ca3-48e5-9864-1da4d6e0d60f");
pub const IID_IGPMGPO = &IID_IGPMGPO_Value;
pub const IGPMGPO = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Path: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*?BSTR,
            ) 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 IGPMGPO,
                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 IGPMGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DomainName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CreationTime: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                pDate: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPO,
                pDate: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ModificationTime: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                pDate: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPO,
                pDate: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_UserDSVersionNumber: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ComputerDSVersionNumber: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_UserSysvolVersionNumber: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ComputerSysvolVersionNumber: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO,
                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 IGPMGPO,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetWMIFilter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                ppIGPMWMIFilter: ?*?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                ppIGPMWMIFilter: ?*?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetWMIFilter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                pIGPMWMIFilter: ?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                pIGPMWMIFilter: ?*IGPMWMIFilter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetUserEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                vbEnabled: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                vbEnabled: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetComputerEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                vbEnabled: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                vbEnabled: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsUserEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsComputerEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Backup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                bstrBackupDir: ?BSTR,
                bstrComment: ?BSTR,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                bstrBackupDir: ?BSTR,
                bstrComment: ?BSTR,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Import: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pIGPMBackup: ?*IGPMBackup,
                pvarMigrationTable: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pIGPMBackup: ?*IGPMBackup,
                pvarMigrationTable: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReportToFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyTo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pIGPMDomain: ?*IGPMDomain,
                pvarNewDisplayName: ?*VARIANT,
                pvarMigrationTable: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pIGPMDomain: ?*IGPMDomain,
                pvarNewDisplayName: ?*VARIANT,
                pvarMigrationTable: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSecurityDescriptor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pSD: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                lFlags: i32,
                pSD: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSecurityDescriptor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                lFlags: i32,
                ppSD: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                lFlags: i32,
                ppSD: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsACLConsistent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
                pvbConsistent: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
                pvbConsistent: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MakeACLConsistent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPO,
            ) 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 IGPMGPO_get_DisplayName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_put_DisplayName(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).put_DisplayName(@as(*const IGPMGPO, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_Path(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_Path(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_ID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_ID(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_DomainName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_DomainName(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_CreationTime(self: *const T, pDate: ?*f64) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_CreationTime(@as(*const IGPMGPO, @ptrCast(self)), pDate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_ModificationTime(self: *const T, pDate: ?*f64) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_ModificationTime(@as(*const IGPMGPO, @ptrCast(self)), pDate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_UserDSVersionNumber(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_UserDSVersionNumber(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_ComputerDSVersionNumber(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_ComputerDSVersionNumber(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_UserSysvolVersionNumber(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_UserSysvolVersionNumber(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_get_ComputerSysvolVersionNumber(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).get_ComputerSysvolVersionNumber(@as(*const IGPMGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_GetWMIFilter(self: *const T, ppIGPMWMIFilter: ?*?*IGPMWMIFilter) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).GetWMIFilter(@as(*const IGPMGPO, @ptrCast(self)), ppIGPMWMIFilter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_SetWMIFilter(self: *const T, pIGPMWMIFilter: ?*IGPMWMIFilter) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).SetWMIFilter(@as(*const IGPMGPO, @ptrCast(self)), pIGPMWMIFilter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_SetUserEnabled(self: *const T, vbEnabled: i16) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).SetUserEnabled(@as(*const IGPMGPO, @ptrCast(self)), vbEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_SetComputerEnabled(self: *const T, vbEnabled: i16) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).SetComputerEnabled(@as(*const IGPMGPO, @ptrCast(self)), vbEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_IsUserEnabled(self: *const T, pvbEnabled: ?*i16) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).IsUserEnabled(@as(*const IGPMGPO, @ptrCast(self)), pvbEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_IsComputerEnabled(self: *const T, pvbEnabled: ?*i16) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).IsComputerEnabled(@as(*const IGPMGPO, @ptrCast(self)), pvbEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).GetSecurityInfo(@as(*const IGPMGPO, @ptrCast(self)), ppSecurityInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).SetSecurityInfo(@as(*const IGPMGPO, @ptrCast(self)), pSecurityInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_Delete(self: *const T) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGPMGPO, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_Backup(self: *const T, bstrBackupDir: ?BSTR, bstrComment: ?BSTR, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).Backup(@as(*const IGPMGPO, @ptrCast(self)), bstrBackupDir, bstrComment, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_Import(self: *const T, lFlags: i32, pIGPMBackup: ?*IGPMBackup, pvarMigrationTable: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).Import(@as(*const IGPMGPO, @ptrCast(self)), lFlags, pIGPMBackup, pvarMigrationTable, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMGPO, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).GenerateReportToFile(@as(*const IGPMGPO, @ptrCast(self)), gpmReportType, bstrTargetFilePath, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_CopyTo(self: *const T, lFlags: i32, pIGPMDomain: ?*IGPMDomain, pvarNewDisplayName: ?*VARIANT, pvarMigrationTable: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).CopyTo(@as(*const IGPMGPO, @ptrCast(self)), lFlags, pIGPMDomain, pvarNewDisplayName, pvarMigrationTable, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_SetSecurityDescriptor(self: *const T, lFlags: i32, pSD: ?*IDispatch) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).SetSecurityDescriptor(@as(*const IGPMGPO, @ptrCast(self)), lFlags, pSD);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_GetSecurityDescriptor(self: *const T, lFlags: i32, ppSD: ?*?*IDispatch) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).GetSecurityDescriptor(@as(*const IGPMGPO, @ptrCast(self)), lFlags, ppSD);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_IsACLConsistent(self: *const T, pvbConsistent: ?*i16) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).IsACLConsistent(@as(*const IGPMGPO, @ptrCast(self)), pvbConsistent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO_MakeACLConsistent(self: *const T) HRESULT {
                return @as(*const IGPMGPO.VTable, @ptrCast(self.vtable)).MakeACLConsistent(@as(*const IGPMGPO, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMGPOCollection_Value = Guid.initString("f0f0d5cf-70ca-4c39-9e29-b642f8726c01");
pub const IID_IGPMGPOCollection = &IID_IGPMGPOCollection_Value;
pub const IGPMGPOCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOCollection,
                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 IGPMGPOCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOCollection,
                lIndex: i32,
                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 IGPMGPOCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOCollection,
                ppIGPMGPOs: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPOCollection,
                ppIGPMGPOs: ?*?*IEnumVARIANT,
            ) 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 IGPMGPOCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPOCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMGPOCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMGPOCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMGPOCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOCollection_get__NewEnum(self: *const T, ppIGPMGPOs: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMGPOCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMGPOCollection, @ptrCast(self)), ppIGPMGPOs);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMGPOLink_Value = Guid.initString("434b99bd-5de7-478a-809c-c251721df70c");
pub const IID_IGPMGPOLink = &IID_IGPMGPOLink_Value;
pub const IGPMGPOLink = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPOID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                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 IGPMGPOLink,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GPODomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                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 IGPMGPOLink,
                pVal: ?*?BSTR,
            ) 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 IGPMGPOLink,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPOLink,
                pVal: ?*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 IGPMGPOLink,
                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 IGPMGPOLink,
                newVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Enforced: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPOLink,
                pVal: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Enforced: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                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 IGPMGPOLink,
                newVal: i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SOMLinkOrder: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                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 IGPMGPOLink,
                lVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SOM: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLink,
                ppIGPMSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPOLink,
                ppIGPMSOM: ?*?*IGPMSOM,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMGPOLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMGPOLink,
            ) 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 IGPMGPOLink_get_GPOID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_GPOID(@as(*const IGPMGPOLink, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_get_GPODomain(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_GPODomain(@as(*const IGPMGPOLink, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_get_Enabled(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_Enabled(@as(*const IGPMGPOLink, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_put_Enabled(self: *const T, newVal: i16) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).put_Enabled(@as(*const IGPMGPOLink, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_get_Enforced(self: *const T, pVal: ?*i16) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_Enforced(@as(*const IGPMGPOLink, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_put_Enforced(self: *const T, newVal: i16) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).put_Enforced(@as(*const IGPMGPOLink, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_get_SOMLinkOrder(self: *const T, lVal: ?*i32) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_SOMLinkOrder(@as(*const IGPMGPOLink, @ptrCast(self)), lVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_get_SOM(self: *const T, ppIGPMSOM: ?*?*IGPMSOM) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).get_SOM(@as(*const IGPMGPOLink, @ptrCast(self)), ppIGPMSOM);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLink_Delete(self: *const T) HRESULT {
                return @as(*const IGPMGPOLink.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGPMGPOLink, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMGPOLinksCollection_Value = Guid.initString("189d7b68-16bd-4d0d-a2ec-2e6aa2288c7f");
pub const IID_IGPMGPOLinksCollection = &IID_IGPMGPOLinksCollection_Value;
pub const IGPMGPOLinksCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLinksCollection,
                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 IGPMGPOLinksCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLinksCollection,
                lIndex: i32,
                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 IGPMGPOLinksCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPOLinksCollection,
                ppIGPMLinks: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPOLinksCollection,
                ppIGPMLinks: ?*?*IEnumVARIANT,
            ) 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 IGPMGPOLinksCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMGPOLinksCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMGPOLinksCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLinksCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMGPOLinksCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMGPOLinksCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPOLinksCollection_get__NewEnum(self: *const T, ppIGPMLinks: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMGPOLinksCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMGPOLinksCollection, @ptrCast(self)), ppIGPMLinks);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMCSECollection_Value = Guid.initString("2e52a97d-0a4a-4a6f-85db-201622455da0");
pub const IID_IGPMCSECollection = &IID_IGPMCSECollection_Value;
pub const IGPMCSECollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMCSECollection,
                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 IGPMCSECollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMCSECollection,
                lIndex: i32,
                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 IGPMCSECollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMCSECollection,
                ppIGPMCSEs: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMCSECollection,
                ppIGPMCSEs: ?*?*IEnumVARIANT,
            ) 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 IGPMCSECollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMCSECollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMCSECollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMCSECollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMCSECollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMCSECollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMCSECollection_get__NewEnum(self: *const T, ppIGPMCSEs: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMCSECollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMCSECollection, @ptrCast(self)), ppIGPMCSEs);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMClientSideExtension_Value = Guid.initString("69da7488-b8db-415e-9266-901be4d49928");
pub const IID_IGPMClientSideExtension = &IID_IGPMClientSideExtension_Value;
pub const IGPMClientSideExtension = 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 IGPMClientSideExtension,
                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 IGPMClientSideExtension,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMClientSideExtension,
                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 IGPMClientSideExtension,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsUserEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMClientSideExtension,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMClientSideExtension,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsComputerEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMClientSideExtension,
                pvbEnabled: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMClientSideExtension,
                pvbEnabled: ?*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 IGPMClientSideExtension_get_ID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMClientSideExtension.VTable, @ptrCast(self.vtable)).get_ID(@as(*const IGPMClientSideExtension, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMClientSideExtension_get_DisplayName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMClientSideExtension.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IGPMClientSideExtension, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMClientSideExtension_IsUserEnabled(self: *const T, pvbEnabled: ?*i16) HRESULT {
                return @as(*const IGPMClientSideExtension.VTable, @ptrCast(self.vtable)).IsUserEnabled(@as(*const IGPMClientSideExtension, @ptrCast(self)), pvbEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMClientSideExtension_IsComputerEnabled(self: *const T, pvbEnabled: ?*i16) HRESULT {
                return @as(*const IGPMClientSideExtension.VTable, @ptrCast(self.vtable)).IsComputerEnabled(@as(*const IGPMClientSideExtension, @ptrCast(self)), pvbEnabled);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMAsyncCancel_Value = Guid.initString("ddc67754-be67-4541-8166-f48166868c9c");
pub const IID_IGPMAsyncCancel = &IID_IGPMAsyncCancel_Value;
pub const IGPMAsyncCancel = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMAsyncCancel,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMAsyncCancel,
            ) 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 IGPMAsyncCancel_Cancel(self: *const T) HRESULT {
                return @as(*const IGPMAsyncCancel.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IGPMAsyncCancel, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMAsyncProgress_Value = Guid.initString("6aac29f8-5948-4324-bf70-423818942dbc");
pub const IID_IGPMAsyncProgress = &IID_IGPMAsyncProgress_Value;
pub const IGPMAsyncProgress = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Status: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMAsyncProgress,
                lProgressNumerator: i32,
                lProgressDenominator: i32,
                hrStatus: HRESULT,
                pResult: ?*VARIANT,
                ppIGPMStatusMsgCollection: ?*IGPMStatusMsgCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMAsyncProgress,
                lProgressNumerator: i32,
                lProgressDenominator: i32,
                hrStatus: HRESULT,
                pResult: ?*VARIANT,
                ppIGPMStatusMsgCollection: ?*IGPMStatusMsgCollection,
            ) 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 IGPMAsyncProgress_Status(self: *const T, lProgressNumerator: i32, lProgressDenominator: i32, hrStatus: HRESULT, pResult: ?*VARIANT, ppIGPMStatusMsgCollection: ?*IGPMStatusMsgCollection) HRESULT {
                return @as(*const IGPMAsyncProgress.VTable, @ptrCast(self.vtable)).Status(@as(*const IGPMAsyncProgress, @ptrCast(self)), lProgressNumerator, lProgressDenominator, hrStatus, pResult, ppIGPMStatusMsgCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStatusMsgCollection_Value = Guid.initString("9b6e1af0-1a92-40f3-a59d-f36ac1f728b7");
pub const IID_IGPMStatusMsgCollection = &IID_IGPMStatusMsgCollection_Value;
pub const IGPMStatusMsgCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMsgCollection,
                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 IGPMStatusMsgCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMsgCollection,
                lIndex: i32,
                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 IGPMStatusMsgCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMsgCollection,
                pVal: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStatusMsgCollection,
                pVal: ?*?*IEnumVARIANT,
            ) 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 IGPMStatusMsgCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMStatusMsgCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMStatusMsgCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMsgCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMStatusMsgCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMStatusMsgCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMsgCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMStatusMsgCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMStatusMsgCollection, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStatusMessage_Value = Guid.initString("8496c22f-f3de-4a1f-8f58-603caaa93d7b");
pub const IID_IGPMStatusMessage = &IID_IGPMStatusMessage_Value;
pub const IGPMStatusMessage = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ObjectPath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMessage,
                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 IGPMStatusMessage,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ErrorCode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStatusMessage,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStatusMessage,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ExtensionName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMessage,
                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 IGPMStatusMessage,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SettingsName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMessage,
                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 IGPMStatusMessage,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OperationCode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStatusMessage,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStatusMessage,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Message: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStatusMessage,
                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 IGPMStatusMessage,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_get_ObjectPath(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).get_ObjectPath(@as(*const IGPMStatusMessage, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_ErrorCode(self: *const T) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).ErrorCode(@as(*const IGPMStatusMessage, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_get_ExtensionName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).get_ExtensionName(@as(*const IGPMStatusMessage, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_get_SettingsName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).get_SettingsName(@as(*const IGPMStatusMessage, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_OperationCode(self: *const T) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).OperationCode(@as(*const IGPMStatusMessage, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStatusMessage_get_Message(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStatusMessage.VTable, @ptrCast(self.vtable)).get_Message(@as(*const IGPMStatusMessage, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMConstants_Value = Guid.initString("50ef73e6-d35c-4c8d-be63-7ea5d2aac5c4");
pub const IID_IGPMConstants = &IID_IGPMConstants_Value;
pub const IGPMConstants = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermGPOApply: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermGPORead: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermGPOEdit: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermGPOEditSecurityAndDelete: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermGPOCustom: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermWMIFilterEdit: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermWMIFilterFullControl: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermWMIFilterCustom: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMLogging: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMPlanning: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMGPOCreate: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMWMICreate: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermSOMWMIFullControl: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOPermissions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOEffectivePermissions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPODisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOWMIFilter: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOComputerExtensions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPOUserExtensions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertySOMLinks: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyGPODomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyBackupMostRecent: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchOpEquals: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchOpContains: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchOpNotContains: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchOpNotEquals: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSearchOperation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_UsePDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_UseAnyDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DoNotUseW2KDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SOMSite: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SOMDomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SOMOU: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMSOMType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SecurityFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                vbOwner: i16,
                vbGroup: i16,
                vbDACL: i16,
                vbSACL: i16,
                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 IGPMConstants,
                vbOwner: i16,
                vbGroup: i16,
                vbDACL: i16,
                vbSACL: i16,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DoNotValidateDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ReportHTML: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMReportType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMReportType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ReportXML: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMReportType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMReportType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RSOPModeUnknown: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RSOPModePlanning: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RSOPModeLogging: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMRSOPMode,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeLocalGroup: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeGlobalGroup: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeUniversalGroup: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeUNCPath: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryTypeUnknown: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestinationOptionSameAsSource: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestinationOptionNone: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestinationOptionByRelativeName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestinationOptionSet: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants,
                pVal: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_MigrationTableOnly: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ProcessSecurity: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopLoggingNoComputer: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopLoggingNoUser: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopPlanningAssumeSlowLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopPlanningLoopbackOption: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                vbMerge: i16,
                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 IGPMConstants,
                vbMerge: i16,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopPlanningAssumeUserWQLFilterTrue: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RsopPlanningAssumeCompWQLFilterTrue: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants,
                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 IGPMConstants,
                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 IGPMConstants_get_PermGPOApply(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermGPOApply(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermGPORead(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermGPORead(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermGPOEdit(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermGPOEdit(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermGPOEditSecurityAndDelete(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermGPOEditSecurityAndDelete(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermGPOCustom(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermGPOCustom(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermWMIFilterEdit(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermWMIFilterEdit(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermWMIFilterFullControl(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermWMIFilterFullControl(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermWMIFilterCustom(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermWMIFilterCustom(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMLink(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMLink(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMLogging(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMLogging(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMPlanning(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMPlanning(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMGPOCreate(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMGPOCreate(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMWMICreate(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMWMICreate(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_PermSOMWMIFullControl(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_PermSOMWMIFullControl(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOPermissions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOPermissions(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOEffectivePermissions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOEffectivePermissions(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPODisplayName(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPODisplayName(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOWMIFilter(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOWMIFilter(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOID(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOID(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOComputerExtensions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOComputerExtensions(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPOUserExtensions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPOUserExtensions(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertySOMLinks(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertySOMLinks(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyGPODomain(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyGPODomain(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchPropertyBackupMostRecent(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchPropertyBackupMostRecent(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchOpEquals(self: *const T, pVal: ?*GPMSearchOperation) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchOpEquals(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchOpContains(self: *const T, pVal: ?*GPMSearchOperation) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchOpContains(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchOpNotContains(self: *const T, pVal: ?*GPMSearchOperation) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchOpNotContains(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SearchOpNotEquals(self: *const T, pVal: ?*GPMSearchOperation) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SearchOpNotEquals(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_UsePDC(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_UsePDC(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_UseAnyDC(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_UseAnyDC(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DoNotUseW2KDC(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DoNotUseW2KDC(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SOMSite(self: *const T, pVal: ?*GPMSOMType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SOMSite(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SOMDomain(self: *const T, pVal: ?*GPMSOMType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SOMDomain(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SOMOU(self: *const T, pVal: ?*GPMSOMType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SOMOU(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_SecurityFlags(self: *const T, vbOwner: i16, vbGroup: i16, vbDACL: i16, vbSACL: i16, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_SecurityFlags(@as(*const IGPMConstants, @ptrCast(self)), vbOwner, vbGroup, vbDACL, vbSACL, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DoNotValidateDC(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DoNotValidateDC(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_ReportHTML(self: *const T, pVal: ?*GPMReportType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_ReportHTML(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_ReportXML(self: *const T, pVal: ?*GPMReportType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_ReportXML(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RSOPModeUnknown(self: *const T, pVal: ?*GPMRSOPMode) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RSOPModeUnknown(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RSOPModePlanning(self: *const T, pVal: ?*GPMRSOPMode) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RSOPModePlanning(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RSOPModeLogging(self: *const T, pVal: ?*GPMRSOPMode) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RSOPModeLogging(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeUser(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeUser(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeComputer(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeComputer(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeLocalGroup(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeLocalGroup(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeGlobalGroup(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeGlobalGroup(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeUniversalGroup(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeUniversalGroup(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeUNCPath(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeUNCPath(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_EntryTypeUnknown(self: *const T, pVal: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_EntryTypeUnknown(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DestinationOptionSameAsSource(self: *const T, pVal: ?*GPMDestinationOption) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DestinationOptionSameAsSource(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DestinationOptionNone(self: *const T, pVal: ?*GPMDestinationOption) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DestinationOptionNone(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DestinationOptionByRelativeName(self: *const T, pVal: ?*GPMDestinationOption) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DestinationOptionByRelativeName(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_DestinationOptionSet(self: *const T, pVal: ?*GPMDestinationOption) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_DestinationOptionSet(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_MigrationTableOnly(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_MigrationTableOnly(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_ProcessSecurity(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_ProcessSecurity(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopLoggingNoComputer(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopLoggingNoComputer(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopLoggingNoUser(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopLoggingNoUser(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopPlanningAssumeSlowLink(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopPlanningAssumeSlowLink(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopPlanningLoopbackOption(self: *const T, vbMerge: i16, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopPlanningLoopbackOption(@as(*const IGPMConstants, @ptrCast(self)), vbMerge, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopPlanningAssumeUserWQLFilterTrue(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopPlanningAssumeUserWQLFilterTrue(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants_get_RsopPlanningAssumeCompWQLFilterTrue(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMConstants.VTable, @ptrCast(self.vtable)).get_RsopPlanningAssumeCompWQLFilterTrue(@as(*const IGPMConstants, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMResult_Value = Guid.initString("86dff7e9-f76f-42ab-9570-cebc6be8a52d");
pub const IID_IGPMResult = &IID_IGPMResult_Value;
pub const IGPMResult = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Status: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMResult,
                ppIGPMStatusMsgCollection: ?*?*IGPMStatusMsgCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMResult,
                ppIGPMStatusMsgCollection: ?*?*IGPMStatusMsgCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Result: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMResult,
                pvarResult: ?*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 IGPMResult,
                pvarResult: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OverallStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMResult,
            ) 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 IGPMResult_get_Status(self: *const T, ppIGPMStatusMsgCollection: ?*?*IGPMStatusMsgCollection) HRESULT {
                return @as(*const IGPMResult.VTable, @ptrCast(self.vtable)).get_Status(@as(*const IGPMResult, @ptrCast(self)), ppIGPMStatusMsgCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMResult_get_Result(self: *const T, pvarResult: ?*VARIANT) HRESULT {
                return @as(*const IGPMResult.VTable, @ptrCast(self.vtable)).get_Result(@as(*const IGPMResult, @ptrCast(self)), pvarResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMResult_OverallStatus(self: *const T) HRESULT {
                return @as(*const IGPMResult.VTable, @ptrCast(self.vtable)).OverallStatus(@as(*const IGPMResult, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMMapEntryCollection_Value = Guid.initString("bb0bf49b-e53f-443f-b807-8be22bfb6d42");
pub const IID_IGPMMapEntryCollection = &IID_IGPMMapEntryCollection_Value;
pub const IGPMMapEntryCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntryCollection,
                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 IGPMMapEntryCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntryCollection,
                lIndex: i32,
                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 IGPMMapEntryCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntryCollection,
                pVal: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMMapEntryCollection,
                pVal: ?*?*IEnumVARIANT,
            ) 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 IGPMMapEntryCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMMapEntryCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMMapEntryCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMapEntryCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMMapEntryCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMMapEntryCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMapEntryCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMMapEntryCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMMapEntryCollection, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMMapEntry_Value = Guid.initString("8e79ad06-2381-4444-be4c-ff693e6e6f2b");
pub const IID_IGPMMapEntry = &IID_IGPMMapEntry_Value;
pub const IGPMMapEntry = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Source: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntry,
                pbstrSource: ?*?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 IGPMMapEntry,
                pbstrSource: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Destination: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntry,
                pbstrDestination: ?*?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 IGPMMapEntry,
                pbstrDestination: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DestinationOption: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntry,
                pgpmDestOption: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMMapEntry,
                pgpmDestOption: ?*GPMDestinationOption,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_EntryType: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMMapEntry,
                pgpmEntryType: ?*GPMEntryType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMMapEntry,
                pgpmEntryType: ?*GPMEntryType,
            ) 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 IGPMMapEntry_get_Source(self: *const T, pbstrSource: ?*?BSTR) HRESULT {
                return @as(*const IGPMMapEntry.VTable, @ptrCast(self.vtable)).get_Source(@as(*const IGPMMapEntry, @ptrCast(self)), pbstrSource);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMapEntry_get_Destination(self: *const T, pbstrDestination: ?*?BSTR) HRESULT {
                return @as(*const IGPMMapEntry.VTable, @ptrCast(self.vtable)).get_Destination(@as(*const IGPMMapEntry, @ptrCast(self)), pbstrDestination);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMapEntry_get_DestinationOption(self: *const T, pgpmDestOption: ?*GPMDestinationOption) HRESULT {
                return @as(*const IGPMMapEntry.VTable, @ptrCast(self.vtable)).get_DestinationOption(@as(*const IGPMMapEntry, @ptrCast(self)), pgpmDestOption);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMapEntry_get_EntryType(self: *const T, pgpmEntryType: ?*GPMEntryType) HRESULT {
                return @as(*const IGPMMapEntry.VTable, @ptrCast(self.vtable)).get_EntryType(@as(*const IGPMMapEntry, @ptrCast(self)), pgpmEntryType);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMMigrationTable_Value = Guid.initString("48f823b1-efaf-470b-b6ed-40d14ee1a4ec");
pub const IID_IGPMMigrationTable = &IID_IGPMMigrationTable_Value;
pub const IGPMMigrationTable = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                bstrMigrationTablePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                bstrMigrationTablePath: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                lFlags: i32,
                @"var": VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                lFlags: i32,
                @"var": VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddEntry: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                gpmEntryType: GPMEntryType,
                pvarDestination: ?*VARIANT,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                gpmEntryType: GPMEntryType,
                pvarDestination: ?*VARIANT,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEntry: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteEntry: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UpdateDestination: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                pvarDestination: ?*VARIANT,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                bstrSource: ?BSTR,
                pvarDestination: ?*VARIANT,
                ppEntry: ?*?*IGPMMapEntry,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Validate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                ppResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                ppResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEntries: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMMigrationTable,
                ppEntries: ?*?*IGPMMapEntryCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMMigrationTable,
                ppEntries: ?*?*IGPMMapEntryCollection,
            ) 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 IGPMMigrationTable_Save(self: *const T, bstrMigrationTablePath: ?BSTR) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).Save(@as(*const IGPMMigrationTable, @ptrCast(self)), bstrMigrationTablePath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_Add(self: *const T, lFlags: i32, @"var": VARIANT) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).Add(@as(*const IGPMMigrationTable, @ptrCast(self)), lFlags, @"var");
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_AddEntry(self: *const T, bstrSource: ?BSTR, gpmEntryType: GPMEntryType, pvarDestination: ?*VARIANT, ppEntry: ?*?*IGPMMapEntry) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).AddEntry(@as(*const IGPMMigrationTable, @ptrCast(self)), bstrSource, gpmEntryType, pvarDestination, ppEntry);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_GetEntry(self: *const T, bstrSource: ?BSTR, ppEntry: ?*?*IGPMMapEntry) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).GetEntry(@as(*const IGPMMigrationTable, @ptrCast(self)), bstrSource, ppEntry);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_DeleteEntry(self: *const T, bstrSource: ?BSTR) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).DeleteEntry(@as(*const IGPMMigrationTable, @ptrCast(self)), bstrSource);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_UpdateDestination(self: *const T, bstrSource: ?BSTR, pvarDestination: ?*VARIANT, ppEntry: ?*?*IGPMMapEntry) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).UpdateDestination(@as(*const IGPMMigrationTable, @ptrCast(self)), bstrSource, pvarDestination, ppEntry);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_Validate(self: *const T, ppResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).Validate(@as(*const IGPMMigrationTable, @ptrCast(self)), ppResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMMigrationTable_GetEntries(self: *const T, ppEntries: ?*?*IGPMMapEntryCollection) HRESULT {
                return @as(*const IGPMMigrationTable.VTable, @ptrCast(self.vtable)).GetEntries(@as(*const IGPMMigrationTable, @ptrCast(self)), ppEntries);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const GPMBackupType = enum(i32) {
    GPO = 0,
    StarterGPO = 1,
};
pub const typeGPO = GPMBackupType.GPO;
pub const typeStarterGPO = GPMBackupType.StarterGPO;

pub const GPMStarterGPOType = enum(i32) {
    System = 0,
    Custom = 1,
};
pub const typeSystem = GPMStarterGPOType.System;
pub const typeCustom = GPMStarterGPOType.Custom;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMBackupDirEx_Value = Guid.initString("f8dc55ed-3ba0-4864-aad4-d365189ee1d5");
pub const IID_IGPMBackupDirEx = &IID_IGPMBackupDirEx_Value;
pub const IGPMBackupDirEx = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupDir: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupDirEx,
                pbstrBackupDir: ?*?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 IGPMBackupDirEx,
                pbstrBackupDir: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupType: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMBackupDirEx,
                pgpmBackupType: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMBackupDirEx,
                pgpmBackupType: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackupDirEx,
                bstrID: ?BSTR,
                pvarBackup: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackupDirEx,
                bstrID: ?BSTR,
                pvarBackup: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchBackups: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMBackupDirEx,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                pvarBackupCollection: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMBackupDirEx,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                pvarBackupCollection: ?*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 IGPMBackupDirEx_get_BackupDir(self: *const T, pbstrBackupDir: ?*?BSTR) HRESULT {
                return @as(*const IGPMBackupDirEx.VTable, @ptrCast(self.vtable)).get_BackupDir(@as(*const IGPMBackupDirEx, @ptrCast(self)), pbstrBackupDir);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupDirEx_get_BackupType(self: *const T, pgpmBackupType: ?*GPMBackupType) HRESULT {
                return @as(*const IGPMBackupDirEx.VTable, @ptrCast(self.vtable)).get_BackupType(@as(*const IGPMBackupDirEx, @ptrCast(self)), pgpmBackupType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupDirEx_GetBackup(self: *const T, bstrID: ?BSTR, pvarBackup: ?*VARIANT) HRESULT {
                return @as(*const IGPMBackupDirEx.VTable, @ptrCast(self.vtable)).GetBackup(@as(*const IGPMBackupDirEx, @ptrCast(self)), bstrID, pvarBackup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMBackupDirEx_SearchBackups(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, pvarBackupCollection: ?*VARIANT) HRESULT {
                return @as(*const IGPMBackupDirEx.VTable, @ptrCast(self.vtable)).SearchBackups(@as(*const IGPMBackupDirEx, @ptrCast(self)), pIGPMSearchCriteria, pvarBackupCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStarterGPOBackupCollection_Value = Guid.initString("c998031d-add0-4bb5-8dea-298505d8423b");
pub const IID_IGPMStarterGPOBackupCollection = &IID_IGPMStarterGPOBackupCollection_Value;
pub const IGPMStarterGPOBackupCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackupCollection,
                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 IGPMStarterGPOBackupCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackupCollection,
                lIndex: i32,
                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 IGPMStarterGPOBackupCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackupCollection,
                ppIGPMTmplBackup: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPOBackupCollection,
                ppIGPMTmplBackup: ?*?*IEnumVARIANT,
            ) 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 IGPMStarterGPOBackupCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMStarterGPOBackupCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMStarterGPOBackupCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackupCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMStarterGPOBackupCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMStarterGPOBackupCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackupCollection_get__NewEnum(self: *const T, ppIGPMTmplBackup: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMStarterGPOBackupCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMStarterGPOBackupCollection, @ptrCast(self)), ppIGPMTmplBackup);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStarterGPOBackup_Value = Guid.initString("51d98eda-a87e-43dd-b80a-0b66ef1938d6");
pub const IID_IGPMStarterGPOBackup = &IID_IGPMStarterGPOBackup_Value;
pub const IGPMStarterGPOBackup = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupDir: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pbstrBackupDir: ?*?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 IGPMStarterGPOBackup,
                pbstrBackupDir: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Comment: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pbstrComment: ?*?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 IGPMStarterGPOBackup,
                pbstrComment: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pbstrDisplayName: ?*?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 IGPMStarterGPOBackup,
                pbstrDisplayName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Domain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pbstrTemplateDomain: ?*?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 IGPMStarterGPOBackup,
                pbstrTemplateDomain: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StarterGPOID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pbstrTemplateID: ?*?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 IGPMStarterGPOBackup,
                pbstrTemplateID: ?*?BSTR,
            ) 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 IGPMStarterGPOBackup,
                pbstrID: ?*?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 IGPMStarterGPOBackup,
                pbstrID: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Timestamp: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pTimestamp: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPOBackup,
                pTimestamp: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Type: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                pType: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPOBackup,
                pType: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPOBackup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPOBackup,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReportToFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPOBackup,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPOBackup,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) 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 IGPMStarterGPOBackup_get_BackupDir(self: *const T, pbstrBackupDir: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_BackupDir(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrBackupDir);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_Comment(self: *const T, pbstrComment: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_Comment(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrComment);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_DisplayName(self: *const T, pbstrDisplayName: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrDisplayName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_Domain(self: *const T, pbstrTemplateDomain: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_Domain(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrTemplateDomain);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_StarterGPOID(self: *const T, pbstrTemplateID: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_StarterGPOID(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrTemplateID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_ID(self: *const T, pbstrID: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_ID(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pbstrID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_Timestamp(self: *const T, pTimestamp: ?*f64) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_Timestamp(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pTimestamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_get_Type(self: *const T, pType: ?*GPMStarterGPOType) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).get_Type(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), pType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_Delete(self: *const T) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGPMStarterGPOBackup, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOBackup_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPOBackup.VTable, @ptrCast(self.vtable)).GenerateReportToFile(@as(*const IGPMStarterGPOBackup, @ptrCast(self)), gpmReportType, bstrTargetFilePath, ppIGPMResult);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPM2_Value = Guid.initString("00238f8a-3d86-41ac-8f5e-06a6638a634a");
pub const IID_IGPM2 = &IID_IGPM2_Value;
pub const IGPM2 = extern struct {
    pub const VTable = extern struct {
        base: IGPM.VTable,
        GetBackupDirEx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM2,
                bstrBackupDir: ?BSTR,
                backupDirType: GPMBackupType,
                ppIGPMBackupDirEx: ?*?*IGPMBackupDirEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM2,
                bstrBackupDir: ?BSTR,
                backupDirType: GPMBackupType,
                ppIGPMBackupDirEx: ?*?*IGPMBackupDirEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InitializeReportingEx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPM2,
                bstrAdmPath: ?BSTR,
                reportingOptions: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPM2,
                bstrAdmPath: ?BSTR,
                reportingOptions: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPM.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM2_GetBackupDirEx(self: *const T, bstrBackupDir: ?BSTR, backupDirType: GPMBackupType, ppIGPMBackupDirEx: ?*?*IGPMBackupDirEx) HRESULT {
                return @as(*const IGPM2.VTable, @ptrCast(self.vtable)).GetBackupDirEx(@as(*const IGPM2, @ptrCast(self)), bstrBackupDir, backupDirType, ppIGPMBackupDirEx);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPM2_InitializeReportingEx(self: *const T, bstrAdmPath: ?BSTR, reportingOptions: i32) HRESULT {
                return @as(*const IGPM2.VTable, @ptrCast(self.vtable)).InitializeReportingEx(@as(*const IGPM2, @ptrCast(self)), bstrAdmPath, reportingOptions);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStarterGPO_Value = Guid.initString("dfc3f61b-8880-4490-9337-d29c7ba8c2f0");
pub const IID_IGPMStarterGPO = &IID_IGPMStarterGPO_Value;
pub const IGPMStarterGPO = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_DisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Author: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Product: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_CreationTime: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pVal: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                pVal: ?*f64,
            ) 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 IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ModifiedTime: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pVal: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                pVal: ?*f64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Type: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ComputerVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pVal: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                pVal: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_UserVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pVal: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPO,
                pVal: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StarterGPOVersion: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                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 IGPMStarterGPO,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                bstrSaveFile: ?BSTR,
                bOverwrite: i16,
                bSaveAsSystem: i16,
                bstrLanguage: ?*VARIANT,
                bstrAuthor: ?*VARIANT,
                bstrProduct: ?*VARIANT,
                bstrUniqueID: ?*VARIANT,
                bstrVersion: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                bstrSaveFile: ?BSTR,
                bOverwrite: i16,
                bSaveAsSystem: i16,
                bstrLanguage: ?*VARIANT,
                bstrAuthor: ?*VARIANT,
                bstrProduct: ?*VARIANT,
                bstrUniqueID: ?*VARIANT,
                bstrVersion: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Backup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                bstrBackupDir: ?BSTR,
                bstrComment: ?BSTR,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                bstrBackupDir: ?BSTR,
                bstrComment: ?BSTR,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyTo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pvarNewDisplayName: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                pvarNewDisplayName: ?*VARIANT,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GenerateReportToFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                gpmReportType: GPMReportType,
                bstrTargetFilePath: ?BSTR,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                ppSecurityInfo: ?*?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSecurityInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMStarterGPO,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMStarterGPO,
                pSecurityInfo: ?*IGPMSecurityInfo,
            ) 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 IGPMStarterGPO_get_DisplayName(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_put_DisplayName(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).put_DisplayName(@as(*const IGPMStarterGPO, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_Description(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_Description(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_put_Description(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).put_Description(@as(*const IGPMStarterGPO, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_Author(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_Author(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_Product(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_Product(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_CreationTime(self: *const T, pVal: ?*f64) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_CreationTime(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_ID(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_ID(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_ModifiedTime(self: *const T, pVal: ?*f64) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_ModifiedTime(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_Type(self: *const T, pVal: ?*GPMStarterGPOType) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_Type(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_ComputerVersion(self: *const T, pVal: ?*u16) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_ComputerVersion(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_UserVersion(self: *const T, pVal: ?*u16) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_UserVersion(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_get_StarterGPOVersion(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).get_StarterGPOVersion(@as(*const IGPMStarterGPO, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_Delete(self: *const T) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGPMStarterGPO, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_Save(self: *const T, bstrSaveFile: ?BSTR, bOverwrite: i16, bSaveAsSystem: i16, bstrLanguage: ?*VARIANT, bstrAuthor: ?*VARIANT, bstrProduct: ?*VARIANT, bstrUniqueID: ?*VARIANT, bstrVersion: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).Save(@as(*const IGPMStarterGPO, @ptrCast(self)), bstrSaveFile, bOverwrite, bSaveAsSystem, bstrLanguage, bstrAuthor, bstrProduct, bstrUniqueID, bstrVersion, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_Backup(self: *const T, bstrBackupDir: ?BSTR, bstrComment: ?BSTR, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).Backup(@as(*const IGPMStarterGPO, @ptrCast(self)), bstrBackupDir, bstrComment, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_CopyTo(self: *const T, pvarNewDisplayName: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).CopyTo(@as(*const IGPMStarterGPO, @ptrCast(self)), pvarNewDisplayName, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMStarterGPO, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).GenerateReportToFile(@as(*const IGPMStarterGPO, @ptrCast(self)), gpmReportType, bstrTargetFilePath, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).GetSecurityInfo(@as(*const IGPMStarterGPO, @ptrCast(self)), ppSecurityInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPO_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) HRESULT {
                return @as(*const IGPMStarterGPO.VTable, @ptrCast(self.vtable)).SetSecurityInfo(@as(*const IGPMStarterGPO, @ptrCast(self)), pSecurityInfo);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMStarterGPOCollection_Value = Guid.initString("2e522729-2219-44ad-933a-64dfd650c423");
pub const IID_IGPMStarterGPOCollection = &IID_IGPMStarterGPOCollection_Value;
pub const IGPMStarterGPOCollection = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOCollection,
                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 IGPMStarterGPOCollection,
                pVal: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Item: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOCollection,
                lIndex: i32,
                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 IGPMStarterGPOCollection,
                lIndex: i32,
                pVal: ?*VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get__NewEnum: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMStarterGPOCollection,
                ppIGPMTemplates: ?*?*IEnumVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMStarterGPOCollection,
                ppIGPMTemplates: ?*?*IEnumVARIANT,
            ) 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 IGPMStarterGPOCollection_get_Count(self: *const T, pVal: ?*i32) HRESULT {
                return @as(*const IGPMStarterGPOCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IGPMStarterGPOCollection, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) HRESULT {
                return @as(*const IGPMStarterGPOCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const IGPMStarterGPOCollection, @ptrCast(self)), lIndex, pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMStarterGPOCollection_get__NewEnum(self: *const T, ppIGPMTemplates: ?*?*IEnumVARIANT) HRESULT {
                return @as(*const IGPMStarterGPOCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const IGPMStarterGPOCollection, @ptrCast(self)), ppIGPMTemplates);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMDomain2_Value = Guid.initString("7ca6bb8b-f1eb-490a-938d-3c4e51c768e6");
pub const IID_IGPMDomain2 = &IID_IGPMDomain2_Value;
pub const IGPMDomain2 = extern struct {
    pub const VTable = extern struct {
        base: IGPMDomain.VTable,
        CreateStarterGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                ppnewTemplate: ?*?*IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                ppnewTemplate: ?*?*IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateGPOFromStarterGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                pGPOTemplate: ?*IGPMStarterGPO,
                ppnewGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                pGPOTemplate: ?*IGPMStarterGPO,
                ppnewGPO: ?*?*IGPMGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStarterGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                bstrGuid: ?BSTR,
                ppTemplate: ?*?*IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                bstrGuid: ?BSTR,
                ppTemplate: ?*?*IGPMStarterGPO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SearchStarterGPOs: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMTemplateCollection: ?*?*IGPMStarterGPOCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                pIGPMSearchCriteria: ?*IGPMSearchCriteria,
                ppIGPMTemplateCollection: ?*?*IGPMStarterGPOCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        LoadStarterGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                bstrLoadFile: ?BSTR,
                bOverwrite: i16,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                bstrLoadFile: ?BSTR,
                bOverwrite: i16,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RestoreStarterGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain2,
                pIGPMTmplBackup: ?*IGPMStarterGPOBackup,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain2,
                pIGPMTmplBackup: ?*IGPMStarterGPOBackup,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPMDomain.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_CreateStarterGPO(self: *const T, ppnewTemplate: ?*?*IGPMStarterGPO) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).CreateStarterGPO(@as(*const IGPMDomain2, @ptrCast(self)), ppnewTemplate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_CreateGPOFromStarterGPO(self: *const T, pGPOTemplate: ?*IGPMStarterGPO, ppnewGPO: ?*?*IGPMGPO) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).CreateGPOFromStarterGPO(@as(*const IGPMDomain2, @ptrCast(self)), pGPOTemplate, ppnewGPO);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_GetStarterGPO(self: *const T, bstrGuid: ?BSTR, ppTemplate: ?*?*IGPMStarterGPO) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).GetStarterGPO(@as(*const IGPMDomain2, @ptrCast(self)), bstrGuid, ppTemplate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_SearchStarterGPOs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMTemplateCollection: ?*?*IGPMStarterGPOCollection) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).SearchStarterGPOs(@as(*const IGPMDomain2, @ptrCast(self)), pIGPMSearchCriteria, ppIGPMTemplateCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_LoadStarterGPO(self: *const T, bstrLoadFile: ?BSTR, bOverwrite: i16, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).LoadStarterGPO(@as(*const IGPMDomain2, @ptrCast(self)), bstrLoadFile, bOverwrite, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain2_RestoreStarterGPO(self: *const T, pIGPMTmplBackup: ?*IGPMStarterGPOBackup, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMDomain2.VTable, @ptrCast(self.vtable)).RestoreStarterGPO(@as(*const IGPMDomain2, @ptrCast(self)), pIGPMTmplBackup, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMConstants2_Value = Guid.initString("05ae21b0-ac09-4032-a26f-9e7da786dc19");
pub const IID_IGPMConstants2 = &IID_IGPMConstants2_Value;
pub const IGPMConstants2 = extern struct {
    pub const VTable = extern struct {
        base: IGPMConstants.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupTypeGPO: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_BackupTypeStarterGPO: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMBackupType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StarterGPOTypeSystem: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_StarterGPOTypeCustom: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMStarterGPOType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyStarterGPOPermissions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyStarterGPOEffectivePermissions: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyStarterGPODisplayName: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyStarterGPOID: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SearchPropertyStarterGPODomain: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMSearchProperty,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermStarterGPORead: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermStarterGPOEdit: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermStarterGPOFullControl: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_PermStarterGPOCustom: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMPermissionType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ReportLegacy: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMReportingOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMReportingOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ReportComments: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMReportingOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMConstants2,
                pVal: ?*GPMReportingOptions,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPMConstants.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_BackupTypeGPO(self: *const T, pVal: ?*GPMBackupType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_BackupTypeGPO(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_BackupTypeStarterGPO(self: *const T, pVal: ?*GPMBackupType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_BackupTypeStarterGPO(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_StarterGPOTypeSystem(self: *const T, pVal: ?*GPMStarterGPOType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_StarterGPOTypeSystem(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_StarterGPOTypeCustom(self: *const T, pVal: ?*GPMStarterGPOType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_StarterGPOTypeCustom(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_SearchPropertyStarterGPOPermissions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_SearchPropertyStarterGPOPermissions(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_SearchPropertyStarterGPOEffectivePermissions(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_SearchPropertyStarterGPOEffectivePermissions(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_SearchPropertyStarterGPODisplayName(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_SearchPropertyStarterGPODisplayName(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_SearchPropertyStarterGPOID(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_SearchPropertyStarterGPOID(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_SearchPropertyStarterGPODomain(self: *const T, pVal: ?*GPMSearchProperty) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_SearchPropertyStarterGPODomain(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_PermStarterGPORead(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_PermStarterGPORead(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_PermStarterGPOEdit(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_PermStarterGPOEdit(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_PermStarterGPOFullControl(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_PermStarterGPOFullControl(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_PermStarterGPOCustom(self: *const T, pVal: ?*GPMPermissionType) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_PermStarterGPOCustom(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_ReportLegacy(self: *const T, pVal: ?*GPMReportingOptions) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_ReportLegacy(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMConstants2_get_ReportComments(self: *const T, pVal: ?*GPMReportingOptions) HRESULT {
                return @as(*const IGPMConstants2.VTable, @ptrCast(self.vtable)).get_ReportComments(@as(*const IGPMConstants2, @ptrCast(self)), pVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPMGPO2_Value = Guid.initString("8a66a210-b78b-4d99-88e2-c306a817c925");
pub const IID_IGPMGPO2 = &IID_IGPMGPO2_Value;
pub const IGPMGPO2 = extern struct {
    pub const VTable = extern struct {
        base: IGPMGPO.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO2,
                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 IGPMGPO2,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Description: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO2,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPO2,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPMGPO.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO2_get_Description(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO2.VTable, @ptrCast(self.vtable)).get_Description(@as(*const IGPMGPO2, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO2_put_Description(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMGPO2.VTable, @ptrCast(self.vtable)).put_Description(@as(*const IGPMGPO2, @ptrCast(self)), newVal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IGPMDomain3_Value = Guid.initString("0077fdfe-88c7-4acf-a11d-d10a7c310a03");
pub const IID_IGPMDomain3 = &IID_IGPMDomain3_Value;
pub const IGPMDomain3 = extern struct {
    pub const VTable = extern struct {
        base: IGPMDomain2.VTable,
        GenerateReport: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPMDomain3,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPMDomain3,
                gpmReportType: GPMReportType,
                pvarGPMProgress: ?*VARIANT,
                pvarGPMCancel: ?*VARIANT,
                ppIGPMResult: ?*?*IGPMResult,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_InfrastructureDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMDomain3,
                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 IGPMDomain3,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_InfrastructureDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMDomain3,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMDomain3,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_InfrastructureFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMDomain3,
                dwFlags: 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 IGPMDomain3,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPMDomain2.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain3_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) HRESULT {
                return @as(*const IGPMDomain3.VTable, @ptrCast(self.vtable)).GenerateReport(@as(*const IGPMDomain3, @ptrCast(self)), gpmReportType, pvarGPMProgress, pvarGPMCancel, ppIGPMResult);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain3_get_InfrastructureDC(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMDomain3.VTable, @ptrCast(self.vtable)).get_InfrastructureDC(@as(*const IGPMDomain3, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain3_put_InfrastructureDC(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMDomain3.VTable, @ptrCast(self.vtable)).put_InfrastructureDC(@as(*const IGPMDomain3, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMDomain3_put_InfrastructureFlags(self: *const T, dwFlags: u32) HRESULT {
                return @as(*const IGPMDomain3.VTable, @ptrCast(self.vtable)).put_InfrastructureFlags(@as(*const IGPMDomain3, @ptrCast(self)), dwFlags);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IGPMGPO3_Value = Guid.initString("7cf123a1-f94a-4112-bfae-6aa1db9cb248");
pub const IID_IGPMGPO3 = &IID_IGPMGPO3_Value;
pub const IGPMGPO3 = extern struct {
    pub const VTable = extern struct {
        base: IGPMGPO2.VTable,
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_InfrastructureDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO3,
                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 IGPMGPO3,
                pVal: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_InfrastructureDC: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO3,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IGPMGPO3,
                newVal: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_InfrastructureFlags: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IGPMGPO3,
                dwFlags: 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 IGPMGPO3,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IGPMGPO2.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO3_get_InfrastructureDC(self: *const T, pVal: ?*?BSTR) HRESULT {
                return @as(*const IGPMGPO3.VTable, @ptrCast(self.vtable)).get_InfrastructureDC(@as(*const IGPMGPO3, @ptrCast(self)), pVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO3_put_InfrastructureDC(self: *const T, newVal: ?BSTR) HRESULT {
                return @as(*const IGPMGPO3.VTable, @ptrCast(self.vtable)).put_InfrastructureDC(@as(*const IGPMGPO3, @ptrCast(self)), newVal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPMGPO3_put_InfrastructureFlags(self: *const T, dwFlags: u32) HRESULT {
                return @as(*const IGPMGPO3.VTable, @ptrCast(self.vtable)).put_InfrastructureFlags(@as(*const IGPMGPO3, @ptrCast(self)), dwFlags);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const GPO_LINK = enum(i32) {
    Unknown = 0,
    Machine = 1,
    Site = 2,
    Domain = 3,
    OrganizationalUnit = 4,
};
pub const GPLinkUnknown = GPO_LINK.Unknown;
pub const GPLinkMachine = GPO_LINK.Machine;
pub const GPLinkSite = GPO_LINK.Site;
pub const GPLinkDomain = GPO_LINK.Domain;
pub const GPLinkOrganizationalUnit = GPO_LINK.OrganizationalUnit;

pub const GROUP_POLICY_OBJECTA = extern struct {
    dwOptions: u32,
    dwVersion: u32,
    lpDSPath: ?PSTR,
    lpFileSysPath: ?PSTR,
    lpDisplayName: ?PSTR,
    szGPOName: [50]CHAR,
    GPOLink: GPO_LINK,
    lParam: LPARAM,
    pNext: ?*GROUP_POLICY_OBJECTA,
    pPrev: ?*GROUP_POLICY_OBJECTA,
    lpExtensions: ?PSTR,
    lParam2: LPARAM,
    lpLink: ?PSTR,
};

pub const GROUP_POLICY_OBJECTW = extern struct {
    dwOptions: u32,
    dwVersion: u32,
    lpDSPath: ?PWSTR,
    lpFileSysPath: ?PWSTR,
    lpDisplayName: ?PWSTR,
    szGPOName: [50]u16,
    GPOLink: GPO_LINK,
    lParam: LPARAM,
    pNext: ?*GROUP_POLICY_OBJECTW,
    pPrev: ?*GROUP_POLICY_OBJECTW,
    lpExtensions: ?PWSTR,
    lParam2: LPARAM,
    lpLink: ?PWSTR,
};

pub const PFNSTATUSMESSAGECALLBACK = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        bVerbose: BOOL,
        lpMessage: ?PWSTR,
    ) callconv(@import("std").os.windows.WINAPI) u32,
    else => *const fn (
        bVerbose: BOOL,
        lpMessage: ?PWSTR,
    ) callconv(@import("std").os.windows.WINAPI) u32,
};

pub const PFNPROCESSGROUPPOLICY = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        dwFlags: u32,
        hToken: ?HANDLE,
        hKeyRoot: ?HKEY,
        pDeletedGPOList: ?*GROUP_POLICY_OBJECTA,
        pChangedGPOList: ?*GROUP_POLICY_OBJECTA,
        pHandle: usize,
        pbAbort: ?*BOOL,
        pStatusCallback: ?PFNSTATUSMESSAGECALLBACK,
    ) callconv(@import("std").os.windows.WINAPI) u32,
    else => *const fn (
        dwFlags: u32,
        hToken: ?HANDLE,
        hKeyRoot: ?HKEY,
        pDeletedGPOList: ?*GROUP_POLICY_OBJECTA,
        pChangedGPOList: ?*GROUP_POLICY_OBJECTA,
        pHandle: usize,
        pbAbort: ?*BOOL,
        pStatusCallback: ?PFNSTATUSMESSAGECALLBACK,
    ) callconv(@import("std").os.windows.WINAPI) u32,
};

pub const PFNPROCESSGROUPPOLICYEX = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        dwFlags: u32,
        hToken: ?HANDLE,
        hKeyRoot: ?HKEY,
        pDeletedGPOList: ?*GROUP_POLICY_OBJECTA,
        pChangedGPOList: ?*GROUP_POLICY_OBJECTA,
        pHandle: usize,
        pbAbort: ?*BOOL,
        pStatusCallback: ?PFNSTATUSMESSAGECALLBACK,
        pWbemServices: ?*IWbemServices,
        pRsopStatus: ?*HRESULT,
    ) callconv(@import("std").os.windows.WINAPI) u32,
    else => *const fn (
        dwFlags: u32,
        hToken: ?HANDLE,
        hKeyRoot: ?HKEY,
        pDeletedGPOList: ?*GROUP_POLICY_OBJECTA,
        pChangedGPOList: ?*GROUP_POLICY_OBJECTA,
        pHandle: usize,
        pbAbort: ?*BOOL,
        pStatusCallback: ?PFNSTATUSMESSAGECALLBACK,
        pWbemServices: ?*IWbemServices,
        pRsopStatus: ?*HRESULT,
    ) callconv(@import("std").os.windows.WINAPI) u32,
};

pub const RSOP_TARGET = extern struct {
    pwszAccountName: ?PWSTR,
    pwszNewSOM: ?PWSTR,
    psaSecurityGroups: ?*SAFEARRAY,
    pRsopToken: ?*anyopaque,
    pGPOList: ?*GROUP_POLICY_OBJECTA,
    pWbemServices: ?*IWbemServices,
};

pub const PFNGENERATEGROUPPOLICY = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        dwFlags: u32,
        pbAbort: ?*BOOL,
        pwszSite: ?PWSTR,
        pComputerTarget: ?*RSOP_TARGET,
        pUserTarget: ?*RSOP_TARGET,
    ) callconv(@import("std").os.windows.WINAPI) u32,
    else => *const fn (
        dwFlags: u32,
        pbAbort: ?*BOOL,
        pwszSite: ?PWSTR,
        pComputerTarget: ?*RSOP_TARGET,
        pUserTarget: ?*RSOP_TARGET,
    ) callconv(@import("std").os.windows.WINAPI) u32,
};

pub const SETTINGSTATUS = enum(i32) {
    Unspecified = 0,
    Applied = 1,
    Ignored = 2,
    Failed = 3,
    SubsettingFailed = 4,
};
pub const RSOPUnspecified = SETTINGSTATUS.Unspecified;
pub const RSOPApplied = SETTINGSTATUS.Applied;
pub const RSOPIgnored = SETTINGSTATUS.Ignored;
pub const RSOPFailed = SETTINGSTATUS.Failed;
pub const RSOPSubsettingFailed = SETTINGSTATUS.SubsettingFailed;

pub const POLICYSETTINGSTATUSINFO = extern struct {
    szKey: ?PWSTR,
    szEventSource: ?PWSTR,
    szEventLogName: ?PWSTR,
    dwEventID: u32,
    dwErrorCode: u32,
    status: SETTINGSTATUS,
    timeLogged: SYSTEMTIME,
};

pub const INSTALLSPECTYPE = enum(i32) {
    APPNAME = 1,
    FILEEXT = 2,
    PROGID = 3,
    COMCLASS = 4,
};
pub const APPNAME = INSTALLSPECTYPE.APPNAME;
pub const FILEEXT = INSTALLSPECTYPE.FILEEXT;
pub const PROGID = INSTALLSPECTYPE.PROGID;
pub const COMCLASS = INSTALLSPECTYPE.COMCLASS;

pub const INSTALLSPEC = extern union {
    AppName: extern struct {
        Name: ?PWSTR,
        GPOId: Guid,
    },
    FileExt: ?PWSTR,
    ProgId: ?PWSTR,
    COMClass: extern struct {
        Clsid: Guid,
        ClsCtx: u32,
    },
};

pub const INSTALLDATA = extern struct {
    Type: INSTALLSPECTYPE,
    Spec: INSTALLSPEC,
};

pub const APPSTATE = enum(i32) {
    ABSENT = 0,
    ASSIGNED = 1,
    PUBLISHED = 2,
};
pub const ABSENT = APPSTATE.ABSENT;
pub const ASSIGNED = APPSTATE.ASSIGNED;
pub const PUBLISHED = APPSTATE.PUBLISHED;

pub const LOCALMANAGEDAPPLICATION = extern struct {
    pszDeploymentName: ?PWSTR,
    pszPolicyName: ?PWSTR,
    pszProductId: ?PWSTR,
    dwState: u32,
};

pub const MANAGEDAPPLICATION = extern struct {
    pszPackageName: ?PWSTR,
    pszPublisher: ?PWSTR,
    dwVersionHi: u32,
    dwVersionLo: u32,
    dwRevision: u32,
    GpoId: Guid,
    pszPolicyName: ?PWSTR,
    ProductId: Guid,
    Language: u16,
    pszOwner: ?PWSTR,
    pszCompany: ?PWSTR,
    pszComments: ?PWSTR,
    pszContact: ?PWSTR,
    pszSupportUrl: ?PWSTR,
    dwPathType: u32,
    bInstalled: BOOL,
};

pub const GROUP_POLICY_OBJECT_TYPE = enum(i32) {
    Local = 0,
    Remote = 1,
    DS = 2,
    LocalUser = 3,
    LocalGroup = 4,
};
pub const GPOTypeLocal = GROUP_POLICY_OBJECT_TYPE.Local;
pub const GPOTypeRemote = GROUP_POLICY_OBJECT_TYPE.Remote;
pub const GPOTypeDS = GROUP_POLICY_OBJECT_TYPE.DS;
pub const GPOTypeLocalUser = GROUP_POLICY_OBJECT_TYPE.LocalUser;
pub const GPOTypeLocalGroup = GROUP_POLICY_OBJECT_TYPE.LocalGroup;

pub const GROUP_POLICY_HINT_TYPE = enum(i32) {
    Unknown = 0,
    Machine = 1,
    Site = 2,
    Domain = 3,
    OrganizationalUnit = 4,
};
pub const GPHintUnknown = GROUP_POLICY_HINT_TYPE.Unknown;
pub const GPHintMachine = GROUP_POLICY_HINT_TYPE.Machine;
pub const GPHintSite = GROUP_POLICY_HINT_TYPE.Site;
pub const GPHintDomain = GROUP_POLICY_HINT_TYPE.Domain;
pub const GPHintOrganizationalUnit = GROUP_POLICY_HINT_TYPE.OrganizationalUnit;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGPEInformation_Value = Guid.initString("8fc0b735-a0e1-11d1-a7d3-0000f87571e3");
pub const IID_IGPEInformation = &IID_IGPEInformation_Value;
pub const IGPEInformation = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDisplayName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRegistryKey: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                dwSection: u32,
                hKey: ?*?HKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                dwSection: u32,
                hKey: ?*?HKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDSPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFileSysPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                dwOptions: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                dwOptions: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                gpoType: ?*GROUP_POLICY_OBJECT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                gpoType: ?*GROUP_POLICY_OBJECT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetHint: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                gpHint: ?*GROUP_POLICY_HINT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                gpHint: ?*GROUP_POLICY_HINT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PolicyChanged: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGPEInformation,
                bMachine: BOOL,
                bAdd: BOOL,
                pGuidExtension: ?*Guid,
                pGuidSnapin: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGPEInformation,
                bMachine: BOOL,
                bAdd: BOOL,
                pGuidExtension: ?*Guid,
                pGuidSnapin: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetName(@as(*const IGPEInformation, @ptrCast(self)), pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetDisplayName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetDisplayName(@as(*const IGPEInformation, @ptrCast(self)), pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetRegistryKey(self: *const T, dwSection: u32, hKey: ?*?HKEY) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetRegistryKey(@as(*const IGPEInformation, @ptrCast(self)), dwSection, hKey);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetDSPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetDSPath(@as(*const IGPEInformation, @ptrCast(self)), dwSection, pszPath, cchMaxPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetFileSysPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetFileSysPath(@as(*const IGPEInformation, @ptrCast(self)), dwSection, pszPath, cchMaxPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetOptions(self: *const T, dwOptions: ?*u32) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetOptions(@as(*const IGPEInformation, @ptrCast(self)), dwOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetType(self: *const T, gpoType: ?*GROUP_POLICY_OBJECT_TYPE) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetType(@as(*const IGPEInformation, @ptrCast(self)), gpoType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_GetHint(self: *const T, gpHint: ?*GROUP_POLICY_HINT_TYPE) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).GetHint(@as(*const IGPEInformation, @ptrCast(self)), gpHint);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGPEInformation_PolicyChanged(self: *const T, bMachine: BOOL, bAdd: BOOL, pGuidExtension: ?*Guid, pGuidSnapin: ?*Guid) HRESULT {
                return @as(*const IGPEInformation.VTable, @ptrCast(self.vtable)).PolicyChanged(@as(*const IGPEInformation, @ptrCast(self)), bMachine, bAdd, pGuidExtension, pGuidSnapin);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IGroupPolicyObject_Value = Guid.initString("ea502723-a23d-11d1-a7d3-0000f87571e3");
pub const IID_IGroupPolicyObject = &IID_IGroupPolicyObject_Value;
pub const IGroupPolicyObject = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        New: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszDomainName: ?PWSTR,
                pszDisplayName: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszDomainName: ?PWSTR,
                pszDisplayName: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenDSGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszPath: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszPath: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenLocalMachineGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenRemoteMachineGPO: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszComputerName: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszComputerName: ?PWSTR,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                bMachine: BOOL,
                bAdd: BOOL,
                pGuidExtension: ?*Guid,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                bMachine: BOOL,
                bAdd: BOOL,
                pGuidExtension: ?*Guid,
                pGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDisplayName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDisplayName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszName: ?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszName: ?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszPath: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszPath: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDSPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFileSysPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                pszPath: [*:0]u16,
                cchMaxPath: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRegistryKey: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                hKey: ?*?HKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwSection: u32,
                hKey: ?*?HKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwOptions: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwOptions: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                dwOptions: u32,
                dwMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                dwOptions: u32,
                dwMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                gpoType: ?*GROUP_POLICY_OBJECT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                gpoType: ?*GROUP_POLICY_OBJECT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMachineName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertySheetPages: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IGroupPolicyObject,
                hPages: ?*?*?HPROPSHEETPAGE,
                uPageCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IGroupPolicyObject,
                hPages: ?*?*?HPROPSHEETPAGE,
                uPageCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_New(self: *const T, pszDomainName: ?PWSTR, pszDisplayName: ?PWSTR, dwFlags: u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).New(@as(*const IGroupPolicyObject, @ptrCast(self)), pszDomainName, pszDisplayName, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_OpenDSGPO(self: *const T, pszPath: ?PWSTR, dwFlags: u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).OpenDSGPO(@as(*const IGroupPolicyObject, @ptrCast(self)), pszPath, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_OpenLocalMachineGPO(self: *const T, dwFlags: u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).OpenLocalMachineGPO(@as(*const IGroupPolicyObject, @ptrCast(self)), dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_OpenRemoteMachineGPO(self: *const T, pszComputerName: ?PWSTR, dwFlags: u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).OpenRemoteMachineGPO(@as(*const IGroupPolicyObject, @ptrCast(self)), pszComputerName, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_Save(self: *const T, bMachine: BOOL, bAdd: BOOL, pGuidExtension: ?*Guid, pGuid: ?*Guid) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).Save(@as(*const IGroupPolicyObject, @ptrCast(self)), bMachine, bAdd, pGuidExtension, pGuid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_Delete(self: *const T) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).Delete(@as(*const IGroupPolicyObject, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetName(@as(*const IGroupPolicyObject, @ptrCast(self)), pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetDisplayName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetDisplayName(@as(*const IGroupPolicyObject, @ptrCast(self)), pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_SetDisplayName(self: *const T, pszName: ?PWSTR) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).SetDisplayName(@as(*const IGroupPolicyObject, @ptrCast(self)), pszName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetPath(self: *const T, pszPath: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetPath(@as(*const IGroupPolicyObject, @ptrCast(self)), pszPath, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetDSPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetDSPath(@as(*const IGroupPolicyObject, @ptrCast(self)), dwSection, pszPath, cchMaxPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetFileSysPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetFileSysPath(@as(*const IGroupPolicyObject, @ptrCast(self)), dwSection, pszPath, cchMaxPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetRegistryKey(self: *const T, dwSection: u32, hKey: ?*?HKEY) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetRegistryKey(@as(*const IGroupPolicyObject, @ptrCast(self)), dwSection, hKey);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetOptions(self: *const T, dwOptions: ?*u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetOptions(@as(*const IGroupPolicyObject, @ptrCast(self)), dwOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_SetOptions(self: *const T, dwOptions: u32, dwMask: u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).SetOptions(@as(*const IGroupPolicyObject, @ptrCast(self)), dwOptions, dwMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetType(self: *const T, gpoType: ?*GROUP_POLICY_OBJECT_TYPE) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetType(@as(*const IGroupPolicyObject, @ptrCast(self)), gpoType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetMachineName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetMachineName(@as(*const IGroupPolicyObject, @ptrCast(self)), pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IGroupPolicyObject_GetPropertySheetPages(self: *const T, hPages: ?*?*?HPROPSHEETPAGE, uPageCount: ?*u32) HRESULT {
                return @as(*const IGroupPolicyObject.VTable, @ptrCast(self.vtable)).GetPropertySheetPages(@as(*const IGroupPolicyObject, @ptrCast(self)), hPages, uPageCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IRSOPInformation_Value = Guid.initString("9a5a81b5-d9c7-49ef-9d11-ddf50968c48d");
pub const IID_IRSOPInformation = &IID_IRSOPInformation_Value;
pub const IRSOPInformation = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetNamespace: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRSOPInformation,
                dwSection: u32,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRSOPInformation,
                dwSection: u32,
                pszName: [*:0]u16,
                cchMaxLength: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFlags: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRSOPInformation,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRSOPInformation,
                pdwFlags: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventLogEntryText: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRSOPInformation,
                pszEventSource: ?PWSTR,
                pszEventLogName: ?PWSTR,
                pszEventTime: ?PWSTR,
                dwEventID: u32,
                ppszText: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRSOPInformation,
                pszEventSource: ?PWSTR,
                pszEventLogName: ?PWSTR,
                pszEventTime: ?PWSTR,
                dwEventID: u32,
                ppszText: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRSOPInformation_GetNamespace(self: *const T, dwSection: u32, pszName: [*:0]u16, cchMaxLength: i32) HRESULT {
                return @as(*const IRSOPInformation.VTable, @ptrCast(self.vtable)).GetNamespace(@as(*const IRSOPInformation, @ptrCast(self)), dwSection, pszName, cchMaxLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRSOPInformation_GetFlags(self: *const T, pdwFlags: ?*u32) HRESULT {
                return @as(*const IRSOPInformation.VTable, @ptrCast(self.vtable)).GetFlags(@as(*const IRSOPInformation, @ptrCast(self)), pdwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRSOPInformation_GetEventLogEntryText(self: *const T, pszEventSource: ?PWSTR, pszEventLogName: ?PWSTR, pszEventTime: ?PWSTR, dwEventID: u32, ppszText: ?*?PWSTR) HRESULT {
                return @as(*const IRSOPInformation.VTable, @ptrCast(self.vtable)).GetEventLogEntryText(@as(*const IRSOPInformation, @ptrCast(self)), pszEventSource, pszEventLogName, pszEventTime, dwEventID, ppszText);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const GPOBROWSEINFO = extern struct {
    dwSize: u32,
    dwFlags: u32,
    hwndOwner: ?HWND,
    lpTitle: ?PWSTR,
    lpInitialOU: ?PWSTR,
    lpDSPath: ?PWSTR,
    dwDSPathSize: u32,
    lpName: ?PWSTR,
    dwNameSize: u32,
    gpoType: GROUP_POLICY_OBJECT_TYPE,
    gpoHint: GROUP_POLICY_HINT_TYPE,
};

//--------------------------------------------------------------------------------
// Section: Functions (32)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RefreshPolicy(
    bMachine: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RefreshPolicyEx(
    bMachine: BOOL,
    dwOptions: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn EnterCriticalPolicySection(
    bMachine: BOOL,
) callconv(@import("std").os.windows.WINAPI) ?HANDLE;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn LeaveCriticalPolicySection(
    hSection: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RegisterGPNotification(
    hEvent: ?HANDLE,
    bMachine: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn UnregisterGPNotification(
    hEvent: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn GetGPOListA(
    hToken: ?HANDLE,
    lpName: ?[*:0]const u8,
    lpHostName: ?[*:0]const u8,
    lpComputerName: ?[*:0]const u8,
    dwFlags: u32,
    pGPOList: ?*?*GROUP_POLICY_OBJECTA,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn GetGPOListW(
    hToken: ?HANDLE,
    lpName: ?[*:0]const u16,
    lpHostName: ?[*:0]const u16,
    lpComputerName: ?[*:0]const u16,
    dwFlags: u32,
    pGPOList: ?*?*GROUP_POLICY_OBJECTW,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn FreeGPOListA(
    pGPOList: ?*GROUP_POLICY_OBJECTA,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn FreeGPOListW(
    pGPOList: ?*GROUP_POLICY_OBJECTW,
) callconv(@import("std").os.windows.WINAPI) BOOL;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn GetAppliedGPOListA(
    dwFlags: u32,
    pMachineName: ?[*:0]const u8,
    pSidUser: ?PSID,
    pGuidExtension: ?*Guid,
    ppGPOList: ?*?*GROUP_POLICY_OBJECTA,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn GetAppliedGPOListW(
    dwFlags: u32,
    pMachineName: ?[*:0]const u16,
    pSidUser: ?PSID,
    pGuidExtension: ?*Guid,
    ppGPOList: ?*?*GROUP_POLICY_OBJECTW,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn ProcessGroupPolicyCompleted(
    extensionId: ?*Guid,
    pAsyncHandle: usize,
    dwStatus: u32,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn ProcessGroupPolicyCompletedEx(
    extensionId: ?*Guid,
    pAsyncHandle: usize,
    dwStatus: u32,
    RsopStatus: HRESULT,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RsopAccessCheckByType(
    pSecurityDescriptor: ?*SECURITY_DESCRIPTOR,
    pPrincipalSelfSid: ?PSID,
    pRsopToken: ?*anyopaque,
    dwDesiredAccessMask: u32,
    pObjectTypeList: ?[*]OBJECT_TYPE_LIST,
    ObjectTypeListLength: u32,
    pGenericMapping: ?*GENERIC_MAPPING,
    // TODO: what to do with BytesParamIndex 8?
    pPrivilegeSet: ?*PRIVILEGE_SET,
    pdwPrivilegeSetLength: ?*u32,
    pdwGrantedAccessMask: ?*u32,
    pbAccessStatus: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RsopFileAccessCheck(
    pszFileName: ?PWSTR,
    pRsopToken: ?*anyopaque,
    dwDesiredAccessMask: u32,
    pdwGrantedAccessMask: ?*u32,
    pbAccessStatus: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RsopSetPolicySettingStatus(
    dwFlags: u32,
    pServices: ?*IWbemServices,
    pSettingInstance: ?*IWbemClassObject,
    nInfo: u32,
    pStatus: [*]POLICYSETTINGSTATUSINFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "userenv" fn RsopResetPolicySettingStatus(
    dwFlags: u32,
    pServices: ?*IWbemServices,
    pSettingInstance: ?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "userenv" fn GenerateGPNotification(
    bMachine: BOOL,
    lpwszMgmtProduct: ?[*:0]const u16,
    dwMgmtProductOptions: u32,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "advapi32" fn InstallApplication(
    pInstallInfo: ?*INSTALLDATA,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "advapi32" fn UninstallApplication(
    ProductCode: ?PWSTR,
    dwStatus: u32,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "advapi32" fn CommandLineFromMsiDescriptor(
    Descriptor: ?PWSTR,
    CommandLine: [*:0]u16,
    CommandLineLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "advapi32" fn GetManagedApplications(
    pCategory: ?*Guid,
    dwQueryFlags: u32,
    dwInfoLevel: u32,
    pdwApps: ?*u32,
    prgManagedApps: ?*?*MANAGEDAPPLICATION,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "advapi32" fn GetLocalManagedApplications(
    bUserApps: BOOL,
    pdwApps: ?*u32,
    prgLocalApps: ?*?*LOCALMANAGEDAPPLICATION,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "advapi32" fn GetLocalManagedApplicationData(
    ProductCode: ?PWSTR,
    DisplayName: ?*?PWSTR,
    SupportUrl: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) void;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "advapi32" fn GetManagedApplicationCategories(
    dwReserved: u32,
    pAppCategory: ?*APPCATEGORYINFOLIST,
) callconv(@import("std").os.windows.WINAPI) u32;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn CreateGPOLink(
    lpGPO: ?PWSTR,
    lpContainer: ?PWSTR,
    fHighPriority: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn DeleteGPOLink(
    lpGPO: ?PWSTR,
    lpContainer: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn DeleteAllGPOLinks(
    lpContainer: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn BrowseForGPO(
    lpBrowseInfo: ?*GPOBROWSEINFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn ImportRSoPData(
    lpNameSpace: ?PWSTR,
    lpFileName: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "gpedit" fn ExportRSoPData(
    lpNameSpace: ?PWSTR,
    lpFileName: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (4)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {
        pub const GROUP_POLICY_OBJECT = thismodule.GROUP_POLICY_OBJECTA;
        pub const GetGPOList = thismodule.GetGPOListA;
        pub const FreeGPOList = thismodule.FreeGPOListA;
        pub const GetAppliedGPOList = thismodule.GetAppliedGPOListA;
    },
    .wide => struct {
        pub const GROUP_POLICY_OBJECT = thismodule.GROUP_POLICY_OBJECTW;
        pub const GetGPOList = thismodule.GetGPOListW;
        pub const FreeGPOList = thismodule.FreeGPOListW;
        pub const GetAppliedGPOList = thismodule.GetAppliedGPOListW;
    },
    .unspecified => if (@import("builtin").is_test) struct {
        pub const GROUP_POLICY_OBJECT = *opaque {};
        pub const GetGPOList = *opaque {};
        pub const FreeGPOList = *opaque {};
        pub const GetAppliedGPOList = *opaque {};
    } else struct {
        pub const GROUP_POLICY_OBJECT = @compileError("'GROUP_POLICY_OBJECT' requires that UNICODE be set to true or false in the root module");
        pub const GetGPOList = @compileError("'GetGPOList' requires that UNICODE be set to true or false in the root module");
        pub const FreeGPOList = @compileError("'FreeGPOList' requires that UNICODE be set to true or false in the root module");
        pub const GetAppliedGPOList = @compileError("'GetAppliedGPOList' requires that UNICODE be set to true or false in the root module");
    },
};
//--------------------------------------------------------------------------------
// Section: Imports (26)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const APPCATEGORYINFOLIST = @import("../ui/shell.zig").APPCATEGORYINFOLIST;
const BOOL = @import("../foundation.zig").BOOL;
const BSTR = @import("../foundation.zig").BSTR;
const CHAR = @import("../foundation.zig").CHAR;
const GENERIC_MAPPING = @import("../security.zig").GENERIC_MAPPING;
const HANDLE = @import("../foundation.zig").HANDLE;
const HKEY = @import("../system/registry.zig").HKEY;
const HPROPSHEETPAGE = @import("../ui/controls.zig").HPROPSHEETPAGE;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const IDispatch = @import("../system/com.zig").IDispatch;
const IEnumVARIANT = @import("../system/ole.zig").IEnumVARIANT;
const IUnknown = @import("../system/com.zig").IUnknown;
const IWbemClassObject = @import("../system/wmi.zig").IWbemClassObject;
const IWbemServices = @import("../system/wmi.zig").IWbemServices;
const LPARAM = @import("../foundation.zig").LPARAM;
const OBJECT_TYPE_LIST = @import("../security.zig").OBJECT_TYPE_LIST;
const PRIVILEGE_SET = @import("../security.zig").PRIVILEGE_SET;
const PSID = @import("../foundation.zig").PSID;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const SAFEARRAY = @import("../system/com.zig").SAFEARRAY;
const SECURITY_DESCRIPTOR = @import("../security.zig").SECURITY_DESCRIPTOR;
const SYSTEMTIME = @import("../foundation.zig").SYSTEMTIME;
const VARIANT = @import("../system/com.zig").VARIANT;

test {
    // The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
    if (@hasDecl(@This(), "PFNSTATUSMESSAGECALLBACK")) {
        _ = PFNSTATUSMESSAGECALLBACK;
    }
    if (@hasDecl(@This(), "PFNPROCESSGROUPPOLICY")) {
        _ = PFNPROCESSGROUPPOLICY;
    }
    if (@hasDecl(@This(), "PFNPROCESSGROUPPOLICYEX")) {
        _ = PFNPROCESSGROUPPOLICYEX;
    }
    if (@hasDecl(@This(), "PFNGENERATEGROUPPOLICY")) {
        _ = PFNGENERATEGROUPPOLICY;
    }

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