7660 lines
415 KiB
Zig
7660 lines
415 KiB
Zig
//! NOTE: this file is autogenerated, DO NOT MODIFY
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Constants (103)
|
|
//--------------------------------------------------------------------------------
|
|
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 GP_DLLNAME = "DllName";
|
|
pub const GP_ENABLEASYNCHRONOUSPROCESSING = "EnableAsynchronousProcessing";
|
|
pub const GP_MAXNOGPOLISTCHANGESINTERVAL = "MaxNoGPOListChangesInterval";
|
|
pub const GP_NOBACKGROUNDPOLICY = "NoBackgroundPolicy";
|
|
pub const GP_NOGPOLISTCHANGES = "NoGPOListChanges";
|
|
pub const GP_NOMACHINEPOLICY = "NoMachinePolicy";
|
|
pub const GP_NOSLOWLINK = "NoSlowLink";
|
|
pub const GP_NOTIFYLINKTRANSITION = "NotifyLinkTransition";
|
|
pub const GP_NOUSERPOLICY = "NoUserPolicy";
|
|
pub const GP_PERUSERLOCALSETTINGS = "PerUserLocalSettings";
|
|
pub const GP_PROCESSGROUPPOLICY = "ProcessGroupPolicy";
|
|
pub const GP_REQUIRESSUCCESSFULREGISTRY = "RequiresSuccessfulRegistry";
|
|
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?
|
|
// TODO: this type has an InvalidHandleValue of '0', 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 fn IGPM_GetDomain(self: *const T, bstrDomain: ?BSTR, bstrDomainController: ?BSTR, lDCFlags: i32, pIGPMDomain: ?*?*IGPMDomain) callconv(.Inline) 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 fn IGPM_GetBackupDir(self: *const T, bstrBackupDir: ?BSTR, pIGPMBackupDir: ?*?*IGPMBackupDir) callconv(.Inline) 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 fn IGPM_GetSitesContainer(self: *const T, bstrForest: ?BSTR, bstrDomain: ?BSTR, bstrDomainController: ?BSTR, lDCFlags: i32, ppIGPMSitesContainer: ?*?*IGPMSitesContainer) callconv(.Inline) 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 fn IGPM_GetRSOP(self: *const T, gpmRSoPMode: GPMRSOPMode, bstrNamespace: ?BSTR, lFlags: i32, ppIGPMRSOP: ?*?*IGPMRSOP) callconv(.Inline) 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 fn IGPM_CreatePermission(self: *const T, bstrTrustee: ?BSTR, perm: GPMPermissionType, bInheritable: i16, ppPerm: ?*?*IGPMPermission) callconv(.Inline) 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 fn IGPM_CreateSearchCriteria(self: *const T, ppIGPMSearchCriteria: ?*?*IGPMSearchCriteria) callconv(.Inline) 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 fn IGPM_CreateTrustee(self: *const T, bstrTrustee: ?BSTR, ppIGPMTrustee: ?*?*IGPMTrustee) callconv(.Inline) 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 fn IGPM_GetClientSideExtensions(self: *const T, ppIGPMCSECollection: ?*?*IGPMCSECollection) callconv(.Inline) 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 fn IGPM_GetConstants(self: *const T, ppIGPMConstants: ?*?*IGPMConstants) callconv(.Inline) 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 fn IGPM_GetMigrationTable(self: *const T, bstrMigrationTablePath: ?BSTR, ppMigrationTable: ?*?*IGPMMigrationTable) callconv(.Inline) 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 fn IGPM_CreateMigrationTable(self: *const T, ppMigrationTable: ?*?*IGPMMigrationTable) callconv(.Inline) 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 fn IGPM_InitializeReporting(self: *const T, bstrAdmPath: ?BSTR) callconv(.Inline) 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 fn IGPMDomain_get_DomainController(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMDomain_get_Domain(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMDomain_CreateGPO(self: *const T, ppNewGPO: ?*?*IGPMGPO) callconv(.Inline) 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 fn IGPMDomain_GetGPO(self: *const T, bstrGuid: ?BSTR, ppGPO: ?*?*IGPMGPO) callconv(.Inline) 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 fn IGPMDomain_SearchGPOs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMGPOCollection: ?*?*IGPMGPOCollection) callconv(.Inline) 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 fn IGPMDomain_RestoreGPO(self: *const T, pIGPMBackup: ?*IGPMBackup, lDCFlags: i32, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMDomain_GetSOM(self: *const T, bstrPath: ?BSTR, ppSOM: ?*?*IGPMSOM) callconv(.Inline) 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 fn IGPMDomain_SearchSOMs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMSOMCollection: ?*?*IGPMSOMCollection) callconv(.Inline) 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 fn IGPMDomain_GetWMIFilter(self: *const T, bstrPath: ?BSTR, ppWMIFilter: ?*?*IGPMWMIFilter) callconv(.Inline) 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 fn IGPMDomain_SearchWMIFilters(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMWMIFilterCollection: ?*?*IGPMWMIFilterCollection) callconv(.Inline) 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 fn IGPMBackupDir_get_BackupDirectory(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackupDir_GetBackup(self: *const T, bstrID: ?BSTR, ppBackup: ?*?*IGPMBackup) callconv(.Inline) 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 fn IGPMBackupDir_SearchBackups(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMBackupCollection: ?*?*IGPMBackupCollection) callconv(.Inline) 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 fn IGPMSitesContainer_get_DomainController(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMSitesContainer_get_Domain(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMSitesContainer_get_Forest(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMSitesContainer_GetSite(self: *const T, bstrSiteName: ?BSTR, ppSOM: ?*?*IGPMSOM) callconv(.Inline) 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 fn IGPMSitesContainer_SearchSites(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMSOMCollection: ?*?*IGPMSOMCollection) callconv(.Inline) 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 fn IGPMSearchCriteria_Add(self: *const T, searchProperty: GPMSearchProperty, searchOperation: GPMSearchOperation, varValue: VARIANT) callconv(.Inline) 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 fn IGPMTrustee_get_TrusteeSid(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMTrustee_get_TrusteeName(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMTrustee_get_TrusteeDomain(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMTrustee_get_TrusteeDSPath(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMTrustee_get_TrusteeType(self: *const T, lVal: ?*i32) callconv(.Inline) 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 fn IGPMPermission_get_Inherited(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMPermission_get_Inheritable(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMPermission_get_Denied(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMPermission_get_Permission(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMPermission_get_Trustee(self: *const T, ppIGPMTrustee: ?*?*IGPMTrustee) callconv(.Inline) 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 fn IGPMSecurityInfo_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMSecurityInfo_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMSecurityInfo_get__NewEnum(self: *const T, ppEnum: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMSecurityInfo_Add(self: *const T, pPerm: ?*IGPMPermission) callconv(.Inline) 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 fn IGPMSecurityInfo_Remove(self: *const T, pPerm: ?*IGPMPermission) callconv(.Inline) 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 fn IGPMSecurityInfo_RemoveTrustee(self: *const T, bstrTrustee: ?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_ID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_GPOID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_GPODomain(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_GPODisplayName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_Timestamp(self: *const T, pVal: ?*f64) callconv(.Inline) 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 fn IGPMBackup_get_Comment(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_get_BackupDir(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackup_Delete(self: *const T) callconv(.Inline) 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 fn IGPMBackup_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMBackup_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMBackupCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMBackupCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMBackupCollection_get__NewEnum(self: *const T, ppIGPMBackup: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMSOM_get_GPOInheritanceBlocked(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMSOM_put_GPOInheritanceBlocked(self: *const T, newVal: i16) callconv(.Inline) 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 fn IGPMSOM_get_Name(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMSOM_get_Path(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMSOM_CreateGPOLink(self: *const T, lLinkPos: i32, pGPO: ?*IGPMGPO, ppNewGPOLink: ?*?*IGPMGPOLink) callconv(.Inline) 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 fn IGPMSOM_get_Type(self: *const T, pVal: ?*GPMSOMType) callconv(.Inline) 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 fn IGPMSOM_GetGPOLinks(self: *const T, ppGPOLinks: ?*?*IGPMGPOLinksCollection) callconv(.Inline) 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 fn IGPMSOM_GetInheritedGPOLinks(self: *const T, ppGPOLinks: ?*?*IGPMGPOLinksCollection) callconv(.Inline) 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 fn IGPMSOM_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMSOM_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMSOMCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMSOMCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMSOMCollection_get__NewEnum(self: *const T, ppIGPMSOM: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMWMIFilter_get_Path(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMWMIFilter_put_Name(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMWMIFilter_get_Name(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMWMIFilter_put_Description(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMWMIFilter_get_Description(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMWMIFilter_GetQueryList(self: *const T, pQryList: ?*VARIANT) callconv(.Inline) 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 fn IGPMWMIFilter_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMWMIFilter_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMWMIFilterCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMWMIFilterCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMWMIFilterCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMRSOP_get_Mode(self: *const T, pVal: ?*GPMRSOPMode) callconv(.Inline) 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 fn IGPMRSOP_get_Namespace(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_LoggingComputer(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_LoggingComputer(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_LoggingUser(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_LoggingUser(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_LoggingFlags(self: *const T, lVal: i32) callconv(.Inline) 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 fn IGPMRSOP_get_LoggingFlags(self: *const T, lVal: ?*i32) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningFlags(self: *const T, lVal: i32) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningFlags(self: *const T, lVal: ?*i32) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningDomainController(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningDomainController(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningSiteName(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningSiteName(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningUser(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningUser(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningUserSOM(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningUserSOM(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningUserWMIFilters(self: *const T, varVal: VARIANT) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningUserWMIFilters(self: *const T, varVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningUserSecurityGroups(self: *const T, varVal: VARIANT) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningUserSecurityGroups(self: *const T, varVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningComputer(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningComputer(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningComputerSOM(self: *const T, bstrVal: ?BSTR) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningComputerSOM(self: *const T, bstrVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningComputerWMIFilters(self: *const T, varVal: VARIANT) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningComputerWMIFilters(self: *const T, varVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMRSOP_put_PlanningComputerSecurityGroups(self: *const T, varVal: VARIANT) callconv(.Inline) 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 fn IGPMRSOP_get_PlanningComputerSecurityGroups(self: *const T, varVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMRSOP_LoggingEnumerateUsers(self: *const T, varVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMRSOP_CreateQueryResults(self: *const T) callconv(.Inline) 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 fn IGPMRSOP_ReleaseQueryResults(self: *const T) callconv(.Inline) 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 fn IGPMRSOP_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMRSOP_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_get_DisplayName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO_put_DisplayName(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMGPO_get_Path(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO_get_ID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO_get_DomainName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO_get_CreationTime(self: *const T, pDate: ?*f64) callconv(.Inline) 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 fn IGPMGPO_get_ModificationTime(self: *const T, pDate: ?*f64) callconv(.Inline) 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 fn IGPMGPO_get_UserDSVersionNumber(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPO_get_ComputerDSVersionNumber(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPO_get_UserSysvolVersionNumber(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPO_get_ComputerSysvolVersionNumber(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPO_GetWMIFilter(self: *const T, ppIGPMWMIFilter: ?*?*IGPMWMIFilter) callconv(.Inline) 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 fn IGPMGPO_SetWMIFilter(self: *const T, pIGPMWMIFilter: ?*IGPMWMIFilter) callconv(.Inline) 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 fn IGPMGPO_SetUserEnabled(self: *const T, vbEnabled: i16) callconv(.Inline) 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 fn IGPMGPO_SetComputerEnabled(self: *const T, vbEnabled: i16) callconv(.Inline) 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 fn IGPMGPO_IsUserEnabled(self: *const T, pvbEnabled: ?*i16) callconv(.Inline) 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 fn IGPMGPO_IsComputerEnabled(self: *const T, pvbEnabled: ?*i16) callconv(.Inline) 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 fn IGPMGPO_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMGPO_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMGPO_Delete(self: *const T) callconv(.Inline) 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 fn IGPMGPO_Backup(self: *const T, bstrBackupDir: ?BSTR, bstrComment: ?BSTR, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_Import(self: *const T, lFlags: i32, pIGPMBackup: ?*IGPMBackup, pvarMigrationTable: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_CopyTo(self: *const T, lFlags: i32, pIGPMDomain: ?*IGPMDomain, pvarNewDisplayName: ?*VARIANT, pvarMigrationTable: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMGPO_SetSecurityDescriptor(self: *const T, lFlags: i32, pSD: ?*IDispatch) callconv(.Inline) 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 fn IGPMGPO_GetSecurityDescriptor(self: *const T, lFlags: i32, ppSD: ?*?*IDispatch) callconv(.Inline) 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 fn IGPMGPO_IsACLConsistent(self: *const T, pvbConsistent: ?*i16) callconv(.Inline) 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 fn IGPMGPO_MakeACLConsistent(self: *const T) callconv(.Inline) 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 fn IGPMGPOCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPOCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMGPOCollection_get__NewEnum(self: *const T, ppIGPMGPOs: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMGPOLink_get_GPOID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPOLink_get_GPODomain(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPOLink_get_Enabled(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMGPOLink_put_Enabled(self: *const T, newVal: i16) callconv(.Inline) 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 fn IGPMGPOLink_get_Enforced(self: *const T, pVal: ?*i16) callconv(.Inline) 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 fn IGPMGPOLink_put_Enforced(self: *const T, newVal: i16) callconv(.Inline) 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 fn IGPMGPOLink_get_SOMLinkOrder(self: *const T, lVal: ?*i32) callconv(.Inline) 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 fn IGPMGPOLink_get_SOM(self: *const T, ppIGPMSOM: ?*?*IGPMSOM) callconv(.Inline) 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 fn IGPMGPOLink_Delete(self: *const T) callconv(.Inline) 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 fn IGPMGPOLinksCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMGPOLinksCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMGPOLinksCollection_get__NewEnum(self: *const T, ppIGPMLinks: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMCSECollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMCSECollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMCSECollection_get__NewEnum(self: *const T, ppIGPMCSEs: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMClientSideExtension_get_ID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMClientSideExtension_get_DisplayName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMClientSideExtension_IsUserEnabled(self: *const T, pvbEnabled: ?*i16) callconv(.Inline) 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 fn IGPMClientSideExtension_IsComputerEnabled(self: *const T, pvbEnabled: ?*i16) callconv(.Inline) 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 fn IGPMAsyncCancel_Cancel(self: *const T) callconv(.Inline) 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 fn IGPMAsyncProgress_Status(self: *const T, lProgressNumerator: i32, lProgressDenominator: i32, hrStatus: HRESULT, pResult: ?*VARIANT, ppIGPMStatusMsgCollection: ?*IGPMStatusMsgCollection) callconv(.Inline) 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 fn IGPMStatusMsgCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMStatusMsgCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMStatusMsgCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMStatusMessage_get_ObjectPath(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStatusMessage_ErrorCode(self: *const T) callconv(.Inline) 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 fn IGPMStatusMessage_get_ExtensionName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStatusMessage_get_SettingsName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStatusMessage_OperationCode(self: *const T) callconv(.Inline) 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 fn IGPMStatusMessage_get_Message(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMConstants_get_PermGPOApply(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermGPORead(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermGPOEdit(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermGPOEditSecurityAndDelete(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermGPOCustom(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermWMIFilterEdit(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermWMIFilterFullControl(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermWMIFilterCustom(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMLink(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMLogging(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMPlanning(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMGPOCreate(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMWMICreate(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_PermSOMWMIFullControl(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOPermissions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOEffectivePermissions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPODisplayName(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOWMIFilter(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOID(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOComputerExtensions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPOUserExtensions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertySOMLinks(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyGPODomain(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchPropertyBackupMostRecent(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants_get_SearchOpEquals(self: *const T, pVal: ?*GPMSearchOperation) callconv(.Inline) 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 fn IGPMConstants_get_SearchOpContains(self: *const T, pVal: ?*GPMSearchOperation) callconv(.Inline) 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 fn IGPMConstants_get_SearchOpNotContains(self: *const T, pVal: ?*GPMSearchOperation) callconv(.Inline) 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 fn IGPMConstants_get_SearchOpNotEquals(self: *const T, pVal: ?*GPMSearchOperation) callconv(.Inline) 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 fn IGPMConstants_get_UsePDC(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_UseAnyDC(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_DoNotUseW2KDC(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_SOMSite(self: *const T, pVal: ?*GPMSOMType) callconv(.Inline) 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 fn IGPMConstants_get_SOMDomain(self: *const T, pVal: ?*GPMSOMType) callconv(.Inline) 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 fn IGPMConstants_get_SOMOU(self: *const T, pVal: ?*GPMSOMType) callconv(.Inline) 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 fn IGPMConstants_get_SecurityFlags(self: *const T, vbOwner: i16, vbGroup: i16, vbDACL: i16, vbSACL: i16, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_DoNotValidateDC(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_ReportHTML(self: *const T, pVal: ?*GPMReportType) callconv(.Inline) 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 fn IGPMConstants_get_ReportXML(self: *const T, pVal: ?*GPMReportType) callconv(.Inline) 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 fn IGPMConstants_get_RSOPModeUnknown(self: *const T, pVal: ?*GPMRSOPMode) callconv(.Inline) 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 fn IGPMConstants_get_RSOPModePlanning(self: *const T, pVal: ?*GPMRSOPMode) callconv(.Inline) 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 fn IGPMConstants_get_RSOPModeLogging(self: *const T, pVal: ?*GPMRSOPMode) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeUser(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeComputer(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeLocalGroup(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeGlobalGroup(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeUniversalGroup(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeUNCPath(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_EntryTypeUnknown(self: *const T, pVal: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMConstants_get_DestinationOptionSameAsSource(self: *const T, pVal: ?*GPMDestinationOption) callconv(.Inline) 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 fn IGPMConstants_get_DestinationOptionNone(self: *const T, pVal: ?*GPMDestinationOption) callconv(.Inline) 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 fn IGPMConstants_get_DestinationOptionByRelativeName(self: *const T, pVal: ?*GPMDestinationOption) callconv(.Inline) 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 fn IGPMConstants_get_DestinationOptionSet(self: *const T, pVal: ?*GPMDestinationOption) callconv(.Inline) 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 fn IGPMConstants_get_MigrationTableOnly(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_ProcessSecurity(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopLoggingNoComputer(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopLoggingNoUser(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopPlanningAssumeSlowLink(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopPlanningLoopbackOption(self: *const T, vbMerge: i16, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopPlanningAssumeUserWQLFilterTrue(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMConstants_get_RsopPlanningAssumeCompWQLFilterTrue(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMResult_get_Status(self: *const T, ppIGPMStatusMsgCollection: ?*?*IGPMStatusMsgCollection) callconv(.Inline) 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 fn IGPMResult_get_Result(self: *const T, pvarResult: ?*VARIANT) callconv(.Inline) 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 fn IGPMResult_OverallStatus(self: *const T) callconv(.Inline) 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 fn IGPMMapEntryCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMMapEntryCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMMapEntryCollection_get__NewEnum(self: *const T, pVal: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMMapEntry_get_Source(self: *const T, pbstrSource: ?*?BSTR) callconv(.Inline) 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 fn IGPMMapEntry_get_Destination(self: *const T, pbstrDestination: ?*?BSTR) callconv(.Inline) 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 fn IGPMMapEntry_get_DestinationOption(self: *const T, pgpmDestOption: ?*GPMDestinationOption) callconv(.Inline) 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 fn IGPMMapEntry_get_EntryType(self: *const T, pgpmEntryType: ?*GPMEntryType) callconv(.Inline) 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 fn IGPMMigrationTable_Save(self: *const T, bstrMigrationTablePath: ?BSTR) callconv(.Inline) 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 fn IGPMMigrationTable_Add(self: *const T, lFlags: i32, @"var": VARIANT) callconv(.Inline) 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 fn IGPMMigrationTable_AddEntry(self: *const T, bstrSource: ?BSTR, gpmEntryType: GPMEntryType, pvarDestination: ?*VARIANT, ppEntry: ?*?*IGPMMapEntry) callconv(.Inline) 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 fn IGPMMigrationTable_GetEntry(self: *const T, bstrSource: ?BSTR, ppEntry: ?*?*IGPMMapEntry) callconv(.Inline) 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 fn IGPMMigrationTable_DeleteEntry(self: *const T, bstrSource: ?BSTR) callconv(.Inline) 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 fn IGPMMigrationTable_UpdateDestination(self: *const T, bstrSource: ?BSTR, pvarDestination: ?*VARIANT, ppEntry: ?*?*IGPMMapEntry) callconv(.Inline) 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 fn IGPMMigrationTable_Validate(self: *const T, ppResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMMigrationTable_GetEntries(self: *const T, ppEntries: ?*?*IGPMMapEntryCollection) callconv(.Inline) 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 fn IGPMBackupDirEx_get_BackupDir(self: *const T, pbstrBackupDir: ?*?BSTR) callconv(.Inline) 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 fn IGPMBackupDirEx_get_BackupType(self: *const T, pgpmBackupType: ?*GPMBackupType) callconv(.Inline) 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 fn IGPMBackupDirEx_GetBackup(self: *const T, bstrID: ?BSTR, pvarBackup: ?*VARIANT) callconv(.Inline) 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 fn IGPMBackupDirEx_SearchBackups(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, pvarBackupCollection: ?*VARIANT) callconv(.Inline) 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 fn IGPMStarterGPOBackupCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMStarterGPOBackupCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMStarterGPOBackupCollection_get__NewEnum(self: *const T, ppIGPMTmplBackup: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_BackupDir(self: *const T, pbstrBackupDir: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_Comment(self: *const T, pbstrComment: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_DisplayName(self: *const T, pbstrDisplayName: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_Domain(self: *const T, pbstrTemplateDomain: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_StarterGPOID(self: *const T, pbstrTemplateID: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_ID(self: *const T, pbstrID: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_Timestamp(self: *const T, pTimestamp: ?*f64) callconv(.Inline) 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 fn IGPMStarterGPOBackup_get_Type(self: *const T, pType: ?*GPMStarterGPOType) callconv(.Inline) 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 fn IGPMStarterGPOBackup_Delete(self: *const T) callconv(.Inline) 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 fn IGPMStarterGPOBackup_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMStarterGPOBackup_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPM2_GetBackupDirEx(self: *const T, bstrBackupDir: ?BSTR, backupDirType: GPMBackupType, ppIGPMBackupDirEx: ?*?*IGPMBackupDirEx) callconv(.Inline) 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 fn IGPM2_InitializeReportingEx(self: *const T, bstrAdmPath: ?BSTR, reportingOptions: i32) callconv(.Inline) 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 fn IGPMStarterGPO_get_DisplayName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_put_DisplayName(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_get_Description(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_put_Description(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_get_Author(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_get_Product(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_get_CreationTime(self: *const T, pVal: ?*f64) callconv(.Inline) 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 fn IGPMStarterGPO_get_ID(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_get_ModifiedTime(self: *const T, pVal: ?*f64) callconv(.Inline) 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 fn IGPMStarterGPO_get_Type(self: *const T, pVal: ?*GPMStarterGPOType) callconv(.Inline) 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 fn IGPMStarterGPO_get_ComputerVersion(self: *const T, pVal: ?*u16) callconv(.Inline) 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 fn IGPMStarterGPO_get_UserVersion(self: *const T, pVal: ?*u16) callconv(.Inline) 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 fn IGPMStarterGPO_get_StarterGPOVersion(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMStarterGPO_Delete(self: *const T) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IGPMStarterGPO_Backup(self: *const T, bstrBackupDir: ?BSTR, bstrComment: ?BSTR, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMStarterGPO_CopyTo(self: *const T, pvarNewDisplayName: ?*VARIANT, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMStarterGPO_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMStarterGPO_GenerateReportToFile(self: *const T, gpmReportType: GPMReportType, bstrTargetFilePath: ?BSTR, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMStarterGPO_GetSecurityInfo(self: *const T, ppSecurityInfo: ?*?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMStarterGPO_SetSecurityInfo(self: *const T, pSecurityInfo: ?*IGPMSecurityInfo) callconv(.Inline) 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 fn IGPMStarterGPOCollection_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) 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 fn IGPMStarterGPOCollection_get_Item(self: *const T, lIndex: i32, pVal: ?*VARIANT) callconv(.Inline) 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 fn IGPMStarterGPOCollection_get__NewEnum(self: *const T, ppIGPMTemplates: ?*?*IEnumVARIANT) callconv(.Inline) 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 fn IGPMDomain2_CreateStarterGPO(self: *const T, ppnewTemplate: ?*?*IGPMStarterGPO) callconv(.Inline) 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 fn IGPMDomain2_CreateGPOFromStarterGPO(self: *const T, pGPOTemplate: ?*IGPMStarterGPO, ppnewGPO: ?*?*IGPMGPO) callconv(.Inline) 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 fn IGPMDomain2_GetStarterGPO(self: *const T, bstrGuid: ?BSTR, ppTemplate: ?*?*IGPMStarterGPO) callconv(.Inline) 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 fn IGPMDomain2_SearchStarterGPOs(self: *const T, pIGPMSearchCriteria: ?*IGPMSearchCriteria, ppIGPMTemplateCollection: ?*?*IGPMStarterGPOCollection) callconv(.Inline) 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 fn IGPMDomain2_LoadStarterGPO(self: *const T, bstrLoadFile: ?BSTR, bOverwrite: i16, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMDomain2_RestoreStarterGPO(self: *const T, pIGPMTmplBackup: ?*IGPMStarterGPOBackup, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMConstants2_get_BackupTypeGPO(self: *const T, pVal: ?*GPMBackupType) callconv(.Inline) 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 fn IGPMConstants2_get_BackupTypeStarterGPO(self: *const T, pVal: ?*GPMBackupType) callconv(.Inline) 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 fn IGPMConstants2_get_StarterGPOTypeSystem(self: *const T, pVal: ?*GPMStarterGPOType) callconv(.Inline) 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 fn IGPMConstants2_get_StarterGPOTypeCustom(self: *const T, pVal: ?*GPMStarterGPOType) callconv(.Inline) 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 fn IGPMConstants2_get_SearchPropertyStarterGPOPermissions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants2_get_SearchPropertyStarterGPOEffectivePermissions(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants2_get_SearchPropertyStarterGPODisplayName(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants2_get_SearchPropertyStarterGPOID(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants2_get_SearchPropertyStarterGPODomain(self: *const T, pVal: ?*GPMSearchProperty) callconv(.Inline) 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 fn IGPMConstants2_get_PermStarterGPORead(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants2_get_PermStarterGPOEdit(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants2_get_PermStarterGPOFullControl(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants2_get_PermStarterGPOCustom(self: *const T, pVal: ?*GPMPermissionType) callconv(.Inline) 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 fn IGPMConstants2_get_ReportLegacy(self: *const T, pVal: ?*GPMReportingOptions) callconv(.Inline) 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 fn IGPMConstants2_get_ReportComments(self: *const T, pVal: ?*GPMReportingOptions) callconv(.Inline) 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 fn IGPMGPO2_get_Description(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO2_put_Description(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMDomain3_GenerateReport(self: *const T, gpmReportType: GPMReportType, pvarGPMProgress: ?*VARIANT, pvarGPMCancel: ?*VARIANT, ppIGPMResult: ?*?*IGPMResult) callconv(.Inline) 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 fn IGPMDomain3_get_InfrastructureDC(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMDomain3_put_InfrastructureDC(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMDomain3_put_InfrastructureFlags(self: *const T, dwFlags: u32) callconv(.Inline) 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 fn IGPMGPO3_get_InfrastructureDC(self: *const T, pVal: ?*?BSTR) callconv(.Inline) 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 fn IGPMGPO3_put_InfrastructureDC(self: *const T, newVal: ?BSTR) callconv(.Inline) 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 fn IGPMGPO3_put_InfrastructureFlags(self: *const T, dwFlags: u32) callconv(.Inline) 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 fn IGPEInformation_GetName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGPEInformation_GetDisplayName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGPEInformation_GetRegistryKey(self: *const T, dwSection: u32, hKey: ?*?HKEY) callconv(.Inline) 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 fn IGPEInformation_GetDSPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) callconv(.Inline) 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 fn IGPEInformation_GetFileSysPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) callconv(.Inline) 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 fn IGPEInformation_GetOptions(self: *const T, dwOptions: ?*u32) callconv(.Inline) 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 fn IGPEInformation_GetType(self: *const T, gpoType: ?*GROUP_POLICY_OBJECT_TYPE) callconv(.Inline) 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 fn IGPEInformation_GetHint(self: *const T, gpHint: ?*GROUP_POLICY_HINT_TYPE) callconv(.Inline) 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 fn IGPEInformation_PolicyChanged(self: *const T, bMachine: BOOL, bAdd: BOOL, pGuidExtension: ?*Guid, pGuidSnapin: ?*Guid) callconv(.Inline) 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 fn IGroupPolicyObject_New(self: *const T, pszDomainName: ?PWSTR, pszDisplayName: ?PWSTR, dwFlags: u32) callconv(.Inline) 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 fn IGroupPolicyObject_OpenDSGPO(self: *const T, pszPath: ?PWSTR, dwFlags: u32) callconv(.Inline) 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 fn IGroupPolicyObject_OpenLocalMachineGPO(self: *const T, dwFlags: u32) callconv(.Inline) 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 fn IGroupPolicyObject_OpenRemoteMachineGPO(self: *const T, pszComputerName: ?PWSTR, dwFlags: u32) callconv(.Inline) 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 fn IGroupPolicyObject_Save(self: *const T, bMachine: BOOL, bAdd: BOOL, pGuidExtension: ?*Guid, pGuid: ?*Guid) callconv(.Inline) 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 fn IGroupPolicyObject_Delete(self: *const T) callconv(.Inline) 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 fn IGroupPolicyObject_GetName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGroupPolicyObject_GetDisplayName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGroupPolicyObject_SetDisplayName(self: *const T, pszName: ?PWSTR) callconv(.Inline) 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 fn IGroupPolicyObject_GetPath(self: *const T, pszPath: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGroupPolicyObject_GetDSPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) callconv(.Inline) 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 fn IGroupPolicyObject_GetFileSysPath(self: *const T, dwSection: u32, pszPath: [*:0]u16, cchMaxPath: i32) callconv(.Inline) 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 fn IGroupPolicyObject_GetRegistryKey(self: *const T, dwSection: u32, hKey: ?*?HKEY) callconv(.Inline) 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 fn IGroupPolicyObject_GetOptions(self: *const T, dwOptions: ?*u32) callconv(.Inline) 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 fn IGroupPolicyObject_SetOptions(self: *const T, dwOptions: u32, dwMask: u32) callconv(.Inline) 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 fn IGroupPolicyObject_GetType(self: *const T, gpoType: ?*GROUP_POLICY_OBJECT_TYPE) callconv(.Inline) 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 fn IGroupPolicyObject_GetMachineName(self: *const T, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IGroupPolicyObject_GetPropertySheetPages(self: *const T, hPages: ?*?*?HPROPSHEETPAGE, uPageCount: ?*u32) callconv(.Inline) 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 fn IRSOPInformation_GetNamespace(self: *const T, dwSection: u32, pszName: [*:0]u16, cchMaxLength: i32) callconv(.Inline) 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 fn IRSOPInformation_GetFlags(self: *const T, pdwFlags: ?*u32) callconv(.Inline) 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 fn IRSOPInformation_GetEventLogEntryText(self: *const T, pszEventSource: ?PWSTR, pszEventLogName: ?PWSTR, pszEventTime: ?PWSTR, dwEventID: u32, ppszText: ?*?PWSTR) callconv(.Inline) 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: ?PSECURITY_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 PSECURITY_DESCRIPTOR = @import("../security.zig").PSECURITY_DESCRIPTOR;
|
|
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 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| {
|
|
_ = @field(@This(), decl.name);
|
|
}
|
|
}
|