Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1233 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/taskschd.rs b/vendor/winapi/src/um/taskschd.rs
new file mode 100644
index 000000000..d73786cd3
--- /dev/null
+++ b/vendor/winapi/src/um/taskschd.rs
@@ -0,0 +1,1233 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+use ctypes::{c_long, c_short};
+use shared::minwindef::{DWORD, INT};
+use shared::wtypes::{BSTR, DATE, VARIANT_BOOL};
+use um::minwinbase::SYSTEMTIME;
+use um::oaidl::{IDispatch, IDispatchVtbl, SAFEARRAY, VARIANT};
+use um::unknwnbase::{IUnknown, IUnknownVtbl, LPUNKNOWN};
+use um::winnt::{HRESULT, LONG};
+RIDL!{#[uuid(0x0f87369f, 0xa4e5, 0x4cfc, 0xbd, 0x3e, 0x73, 0xe6, 0x15, 0x45, 0x72, 0xdd)]
+class TaskScheduler;}
+RIDL!{#[uuid(0xf2a69db7, 0xda2c, 0x4352, 0x90, 0x66, 0x86, 0xfe, 0xe6, 0xda, 0xca, 0xc9)]
+class TaskHandlerPS;}
+RIDL!{#[uuid(0x9f15266d, 0xd7ba, 0x48f0, 0x93, 0xc1, 0xe6, 0x89, 0x5f, 0x6f, 0xe5, 0xac)]
+class TaskHandlerStatusPS;}
+RIDL!{#[uuid(0x79184a66, 0x8664, 0x423f, 0x97, 0xf1, 0x63, 0x73, 0x56, 0xa5, 0xd8, 0x12)]
+interface ITaskFolderCollection(ITaskFolderCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut LONG,
+    ) -> HRESULT,
+    fn get_Item(
+        index: VARIANT,
+        ppFolder: *mut *mut ITaskFolder,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8cfac062, 0xa080, 0x4c15, 0x9a, 0x88, 0xaa, 0x7c, 0x2a, 0xf8, 0x0d, 0xfc)]
+interface ITaskFolder(ITaskFolderVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Name(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn get_Path(
+        pPath: *mut BSTR,
+    ) -> HRESULT,
+    fn GetFolder(
+        Path: BSTR,
+        ppFolder: *mut *mut ITaskFolder,
+    ) -> HRESULT,
+    fn GetFolders(
+        flags: LONG,
+        ppFolders: *mut *mut ITaskFolderCollection,
+    ) -> HRESULT,
+    fn CreateFolder(
+        subFolderName: BSTR,
+        sddl: VARIANT,
+        ppFolder: *mut *mut ITaskFolder,
+    ) -> HRESULT,
+    fn DeleteFolder(
+        subFolderName: BSTR,
+        flags: LONG,
+    ) -> HRESULT,
+    fn GetTask(
+        Path: BSTR,
+        ppTask: *mut *mut IRegisteredTask,
+    ) -> HRESULT,
+    fn GetTasks(
+        flags: LONG,
+        ppTasks: *mut *mut IRegisteredTaskCollection,
+    ) -> HRESULT,
+    fn DeleteTask(
+        Name: BSTR,
+        flags: LONG,
+    ) -> HRESULT,
+    fn RegisterTask(
+        Path: BSTR,
+        XmlText: BSTR,
+        flags: LONG,
+        UserId: VARIANT,
+        password: VARIANT,
+        LogonType: TASK_LOGON_TYPE,
+        sddl: VARIANT,
+        ppTask: *mut *mut IRegisteredTask,
+    ) -> HRESULT,
+    fn RegisterTaskDefinition(
+        Path: BSTR,
+        pDefinition: *const ITaskDefinition,
+        flags: LONG,
+        UserId: VARIANT,
+        password: VARIANT,
+        LogonType: TASK_LOGON_TYPE,
+        sddl: VARIANT,
+        ppTask: *mut *mut IRegisteredTask,
+    ) -> HRESULT,
+    fn GetSecurityDescriptor(
+        securityInformation: LONG,
+        pSddl: *mut BSTR,
+    ) -> HRESULT,
+    fn SetSecurityDescriptor(
+        sddl: BSTR,
+        flags: LONG,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x9c86f320, 0xdee3, 0x4dd1, 0xb9, 0x72, 0xa3, 0x03, 0xf2, 0x6b, 0x06, 0x1e)]
+interface IRegisteredTask(IRegisteredTaskVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Name(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn get_Path(
+        pPath: *mut BSTR,
+    ) -> HRESULT,
+    fn get_State(
+        pState: *mut TASK_STATE,
+    ) -> HRESULT,
+    fn get_Enabled(
+        pEnabled: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_Enabled(
+        pEnabled: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn Run(
+        params: VARIANT,
+        ppRunningTask: *mut *mut IRunningTask,
+    ) -> HRESULT,
+    fn RunEx(
+        params: VARIANT,
+        flags: LONG,
+        sessionID: LONG,
+        user: BSTR,
+        ppRunningTask: *mut *mut IRunningTask,
+    ) -> HRESULT,
+    fn GetInstances(
+        flags: LONG,
+        ppRunningTasks: *mut *mut IRunningTaskCollection,
+    ) -> HRESULT,
+    fn get_LastRunTime(
+        pLastRunTime: *mut DATE,
+    ) -> HRESULT,
+    fn get_LastTaskResult(
+        pLastTaskResult: *mut LONG,
+    ) -> HRESULT,
+    fn get_NumberOfMissedRuns(
+        pNumberOfMissedRuns: *mut LONG,
+    ) -> HRESULT,
+    fn get_NextRunTime(
+        pNextRunTime: *mut DATE,
+    ) -> HRESULT,
+    fn get_Definition(
+        ppDefinition: *mut *mut ITaskDefinition,
+    ) -> HRESULT,
+    fn get_Xml(
+        pXml: *mut BSTR,
+    ) -> HRESULT,
+    fn GetSecurityDescriptor(
+        securityInformation: LONG,
+        pSddl: *mut BSTR,
+    ) -> HRESULT,
+    fn SetSecurityDescriptor(
+        sddl: BSTR,
+        flags: LONG,
+    ) -> HRESULT,
+    fn Stop(
+        flags: LONG,
+    ) -> HRESULT,
+    fn GetRunTimes(
+        pstStart: *const SYSTEMTIME,
+        pstEnd: *const SYSTEMTIME,
+        pCount: *mut DWORD,
+        pRunTimes: *mut *mut SYSTEMTIME,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_STATE {
+    TASK_STATE_UNKNOWN = 0,
+    TASK_STATE_DISABLED = 1,
+    TASK_STATE_QUEUED = 2,
+    TASK_STATE_READY = 3,
+    TASK_STATE_RUNNING = 4,
+}}
+RIDL!{#[uuid(0x653758fb, 0x7b9a, 0x4f1e, 0xa4, 0x71, 0xbe, 0xeb, 0x8e, 0x9b, 0x83, 0x4e)]
+interface IRunningTask(IRunningTaskVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Name(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn get_InstanceGuid(
+        pGuid: *mut BSTR,
+    ) -> HRESULT,
+    fn get_Path(
+        pPath: *mut BSTR,
+    ) -> HRESULT,
+    fn get_State(
+        pState: *mut TASK_STATE,
+    ) -> HRESULT,
+    fn get_CurrentAction(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn Stop() -> HRESULT,
+    fn Refresh() -> HRESULT,
+    fn get_EnginePID(
+        pPID: *mut DWORD,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x6a67614b, 0x6828, 0x4fec, 0xaa, 0x54, 0x6d, 0x52, 0xe8, 0xf1, 0xf2, 0xdb)]
+interface IRunningTaskCollection(IRunningTaskCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut LONG,
+    ) -> HRESULT,
+    fn get_Item(
+        index: VARIANT,
+        ppRunningTask: *mut *mut IRunningTask,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xf5bc8fc5, 0x536d, 0x4f77, 0xb8, 0x52, 0xfb, 0xc1, 0x35, 0x6f, 0xde, 0xb6)]
+interface ITaskDefinition(ITaskDefinitionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_RegistrationInfo(
+        ppRegistrationInfo: *mut *mut IRegistrationInfo,
+    ) -> HRESULT,
+    fn put_RegistrationInfo(
+        ppRegistrationInfo: *const IRegistrationInfo,
+    ) -> HRESULT,
+    fn get_Triggers(
+        ppTriggers: *mut *mut ITriggerCollection,
+    ) -> HRESULT,
+    fn put_Triggers(
+        ppTriggers: *const ITriggerCollection,
+    ) -> HRESULT,
+    fn get_Settings(
+        ppSettings: *mut *mut ITaskSettings,
+    ) -> HRESULT,
+    fn put_Settings(
+        ppSettings: *const ITaskSettings,
+    ) -> HRESULT,
+    fn get_Data(
+        pData: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Data(
+        pData: BSTR,
+    ) -> HRESULT,
+    fn get_Principal(
+        ppPrincipal: *mut *mut IPrincipal,
+    ) -> HRESULT,
+    fn put_Principal(
+        ppPrincipal: *const IPrincipal,
+    ) -> HRESULT,
+    fn get_Actions(
+        ppActions: *mut *mut IActionCollection,
+    ) -> HRESULT,
+    fn put_Actions(
+        ppActions: *const IActionCollection,
+    ) -> HRESULT,
+    fn get_XmlText(
+        pXml: *mut BSTR,
+    ) -> HRESULT,
+    fn put_XmlText(
+        pXml: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x416d8b73, 0xcb41, 0x4ea1, 0x80, 0x5c, 0x9b, 0xe9, 0xa5, 0xac, 0x4a, 0x74)]
+interface IRegistrationInfo(IRegistrationInfoVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Description(
+        pDescription: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Description(
+        pDescription: BSTR,
+    ) -> HRESULT,
+    fn get_Author(
+        pAuthor: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Author(
+        pAuthor: BSTR,
+    ) -> HRESULT,
+    fn get_Version(
+        pVersion: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Version(
+        pVersion: BSTR,
+    ) -> HRESULT,
+    fn get_Date(
+        pDate: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Date(
+        pDate: BSTR,
+    ) -> HRESULT,
+    fn get_Documentation(
+        pDocumentation: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Documentation(
+        pDocumentation: BSTR,
+    ) -> HRESULT,
+    fn get_XmlText(
+        pText: *mut BSTR,
+    ) -> HRESULT,
+    fn put_XmlText(
+        pText: BSTR,
+    ) -> HRESULT,
+    fn get_URI(
+        pUri: *mut BSTR,
+    ) -> HRESULT,
+    fn put_URI(
+        pUri: BSTR,
+    ) -> HRESULT,
+    fn get_SecurityDescriptor(
+        pSddl: *mut VARIANT,
+    ) -> HRESULT,
+    fn put_SecurityDescriptor(
+        pSddl: VARIANT,
+    ) -> HRESULT,
+    fn get_Source(
+        pSource: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Source(
+        pSource: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x85df5081, 0x1b24, 0x4f32, 0x87, 0x8a, 0xd9, 0xd1, 0x4d, 0xf4, 0xcb, 0x77)]
+interface ITriggerCollection(ITriggerCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut c_long,
+    ) -> HRESULT,
+    fn get_Item(
+        index: c_long,
+        ppTrigger: *mut *mut ITrigger,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+    fn Create(
+        Type: TASK_TRIGGER_TYPE2,
+        ppTrigger: *mut *mut ITrigger,
+    ) -> HRESULT,
+    fn Remove(
+        index: VARIANT,
+    ) -> HRESULT,
+    fn Clear() -> HRESULT,
+}}
+RIDL!{#[uuid(0x09941815, 0xea89, 0x4b5b, 0x89, 0xe0, 0x2a, 0x77, 0x38, 0x01, 0xfa, 0xc3)]
+interface ITrigger(ITriggerVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Type(
+        pType: *mut TASK_TRIGGER_TYPE2,
+    ) -> HRESULT,
+    fn get_Id(
+        pId: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Id(
+        pId: BSTR,
+    ) -> HRESULT,
+    fn get_Repetition(
+        ppRepeat: *mut *mut IRepetitionPattern,
+    ) -> HRESULT,
+    fn put_Repetition(
+        ppRepeat: *const IRepetitionPattern,
+    ) -> HRESULT,
+    fn get_ExecutionTimeLimit(
+        pTimeLimit: *mut BSTR,
+    ) -> HRESULT,
+    fn put_ExecutionTimeLimit(
+        pTimeLimit: BSTR,
+    ) -> HRESULT,
+    fn get_StartBoundary(
+        pStart: *mut BSTR,
+    ) -> HRESULT,
+    fn put_StartBoundary(
+        pStart: BSTR,
+    ) -> HRESULT,
+    fn get_EndBoundary(
+        pEnd: *mut BSTR,
+    ) -> HRESULT,
+    fn put_EndBoundary(
+        pEnd: BSTR,
+    ) -> HRESULT,
+    fn get_Enabled(
+        pEnabled: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_Enabled(
+        pEnabled: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_TRIGGER_TYPE2 {
+    TASK_TRIGGER_EVENT = 0,
+    TASK_TRIGGER_TIME = 1,
+    TASK_TRIGGER_DAILY = 2,
+    TASK_TRIGGER_WEEKLY = 3,
+    TASK_TRIGGER_MONTHLY = 4,
+    TASK_TRIGGER_MONTHLYDOW = 5,
+    TASK_TRIGGER_IDLE = 6,
+    TASK_TRIGGER_REGISTRATION = 7,
+    TASK_TRIGGER_BOOT = 8,
+    TASK_TRIGGER_LOGON = 9,
+    TASK_TRIGGER_SESSION_STATE_CHANGE = 11,
+    TASK_TRIGGER_CUSTOM_TRIGGER_01 = 12,
+}}
+RIDL!{#[uuid(0x7fb9acf1, 0x26be, 0x400e, 0x85, 0xb5, 0x29, 0x4b, 0x9c, 0x75, 0xdf, 0xd6)]
+interface IRepetitionPattern(IRepetitionPatternVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Interval(
+        pInterval: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Interval(
+        pInterval: BSTR,
+    ) -> HRESULT,
+    fn get_Duration(
+        pDuration: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Duration(
+        pDuration: BSTR,
+    ) -> HRESULT,
+    fn get_StopAtDurationEnd(
+        pStop: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_StopAtDurationEnd(
+        pStop: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x8fd4711d, 0x2d02, 0x4c8c, 0x87, 0xe3, 0xef, 0xf6, 0x99, 0xde, 0x12, 0x7e)]
+interface ITaskSettings(ITaskSettingsVtbl): IDispatch(IDispatchVtbl) {
+    fn get_AllowDemandStart(
+        pAllowDemandStart: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_AllowDemandStart(
+        pAllowDemandStart: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_RestartInterval(
+        pRestartInterval: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RestartInterval(
+        pRestartInterval: BSTR,
+    ) -> HRESULT,
+    fn get_RestartCount(
+        pRestartCount: *mut INT,
+    ) -> HRESULT,
+    fn put_RestartCount(
+        pRestartCount: INT,
+    ) -> HRESULT,
+    fn get_MultipleInstances(
+        pPolicy: *mut TASK_INSTANCES_POLICY,
+    ) -> HRESULT,
+    fn put_MultipleInstances(
+        pPolicy: TASK_INSTANCES_POLICY,
+    ) -> HRESULT,
+    fn get_StopIfGoingOnBatteries(
+        pStopIfOnBatteries: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_StopIfGoingOnBatteries(
+        pStopIfOnBatteries: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_DisallowStartIfOnBatteries(
+        pDisallowStart: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_DisallowStartIfOnBatteries(
+        pDisallowStart: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_AllowHardTerminate(
+        pAllowHardTerminate: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_AllowHardTerminate(
+        pAllowHardTerminate: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_StartWhenAvailable(
+        pStartWhenAvailable: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_StartWhenAvailable(
+        pStartWhenAvailable: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_XmlText(
+        pText: *mut BSTR,
+    ) -> HRESULT,
+    fn put_XmlText(
+        pText: BSTR,
+    ) -> HRESULT,
+    fn get_RunOnlyIfNetworkAvailable(
+        pRunOnlyIfNetworkAvailable: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_RunOnlyIfNetworkAvailable(
+        pRunOnlyIfNetworkAvailable: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_ExecutionTimeLimit(
+        pExecutionTimeLimit: *mut BSTR,
+    ) -> HRESULT,
+    fn put_ExecutionTimeLimit(
+        pExecutionTimeLimit: BSTR,
+    ) -> HRESULT,
+    fn get_Enabled(
+        pEnabled: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_Enabled(
+        pEnabled: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_DeleteExpiredTaskAfter(
+        pExpirationDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_DeleteExpiredTaskAfter(
+        pExpirationDelay: BSTR,
+    ) -> HRESULT,
+    fn get_Priority(
+        pPriority: *mut INT,
+    ) -> HRESULT,
+    fn put_Priority(
+        pPriority: INT,
+    ) -> HRESULT,
+    fn get_Compatibility(
+        pCompatLevel: *mut TASK_COMPATIBILITY,
+    ) -> HRESULT,
+    fn put_Compatibility(
+        pCompatLevel: TASK_COMPATIBILITY,
+    ) -> HRESULT,
+    fn get_Hidden(
+        pHidden: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_Hidden(
+        pHidden: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_IdleSettings(
+        ppIdleSettings: *mut *mut IIdleSettings,
+    ) -> HRESULT,
+    fn put_IdleSettings(
+        ppIdleSettings: *const IIdleSettings,
+    ) -> HRESULT,
+    fn get_RunOnlyIfIdle(
+        pRunOnlyIfIdle: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_RunOnlyIfIdle(
+        pRunOnlyIfIdle: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_WakeToRun(
+        pWake: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_WakeToRun(
+        pWake: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_NetworkSettings(
+        ppNetworkSettings: *mut *mut INetworkSettings,
+    ) -> HRESULT,
+    fn put_NetworkSettings(
+        ppNetworkSettings: *const INetworkSettings,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_INSTANCES_POLICY {
+    TASK_INSTANCES_PARALLEL = 0,
+    TASK_INSTANCES_QUEUE = 1,
+    TASK_INSTANCES_IGNORE_NEW = 2,
+    TASK_INSTANCES_STOP_EXISTING = 3,
+}}
+ENUM!{enum TASK_COMPATIBILITY {
+    TASK_COMPATIBILITY_AT = 0,
+    TASK_COMPATIBILITY_V1 = 1,
+    TASK_COMPATIBILITY_V2 = 2,
+    TASK_COMPATIBILITY_V2_1 = 3,
+    TASK_COMPATIBILITY_V2_2 = 4,
+    TASK_COMPATIBILITY_V2_3 = 5,
+    TASK_COMPATIBILITY_V2_4 = 6,
+}}
+RIDL!{#[uuid(0x84594461, 0x0053, 0x4342, 0xa8, 0xfd, 0x08, 0x8f, 0xab, 0xf1, 0x1f, 0x32)]
+interface IIdleSettings(IIdleSettingsVtbl): IDispatch(IDispatchVtbl) {
+    fn get_IdleDuration(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_IdleDuration(
+        pDelay: BSTR,
+    ) -> HRESULT,
+    fn get_WaitTimeout(
+        pTimeout: *mut BSTR,
+    ) -> HRESULT,
+    fn put_WaitTimeout(
+        pTimeout: BSTR,
+    ) -> HRESULT,
+    fn get_StopOnIdleEnd(
+        pStop: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_StopOnIdleEnd(
+        pStop: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_RestartOnIdle(
+        pRestart: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_RestartOnIdle(
+        pRestart: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x9f7dea84, 0xc30b, 0x4245, 0x80, 0xb6, 0x00, 0xe9, 0xf6, 0x46, 0xf1, 0xb4)]
+interface INetworkSettings(INetworkSettingsVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Name(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Name(
+        pName: BSTR,
+    ) -> HRESULT,
+    fn get_Id(
+        pId: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Id(
+        pId: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xd98d51e5, 0xc9b4, 0x496a, 0xa9, 0xc1, 0x18, 0x98, 0x02, 0x61, 0xcf, 0x0f)]
+interface IPrincipal(IPrincipalVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Id(
+        pId: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Id(
+        pId: BSTR,
+    ) -> HRESULT,
+    fn get_DisplayName(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn put_DisplayName(
+        pName: BSTR,
+    ) -> HRESULT,
+    fn get_UserId(
+        pUser: *mut BSTR,
+    ) -> HRESULT,
+    fn put_UserId(
+        pUser: BSTR,
+    ) -> HRESULT,
+    fn get_LogonType(
+        pLogon: *mut TASK_LOGON_TYPE,
+    ) -> HRESULT,
+    fn put_LogonType(
+        pLogon: TASK_LOGON_TYPE,
+    ) -> HRESULT,
+    fn get_GroupId(
+        pGroup: *mut BSTR,
+    ) -> HRESULT,
+    fn put_GroupId(
+        pGroup: BSTR,
+    ) -> HRESULT,
+    fn get_RunLevel(
+        pRunLevel: *mut TASK_RUNLEVEL,
+    ) -> HRESULT,
+    fn put_RunLevel(
+        pRunLevel: TASK_RUNLEVEL,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_LOGON_TYPE {
+    TASK_LOGON_NONE = 0,
+    TASK_LOGON_PASSWORD = 1,
+    TASK_LOGON_S4U = 2,
+    TASK_LOGON_INTERACTIVE_TOKEN = 3,
+    TASK_LOGON_GROUP = 4,
+    TASK_LOGON_SERVICE_ACCOUNT = 5,
+    TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD = 6,
+}}
+ENUM!{enum TASK_RUNLEVEL {
+    TASK_RUNLEVEL_LUA = 0,
+    TASK_RUNLEVEL_HIGHEST = 1,
+}}
+RIDL!{#[uuid(0x02820e19, 0x7b98, 0x4ed2, 0xb2, 0xe8, 0xfd, 0xcc, 0xce, 0xff, 0x61, 0x9b)]
+interface IActionCollection(IActionCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut c_long,
+    ) -> HRESULT,
+    fn get_Item(
+        index: c_long,
+        ppAction: *mut *mut IAction,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+    fn get_XmlText(
+        pText: *mut BSTR,
+    ) -> HRESULT,
+    fn put_XmlText(
+        pText: BSTR,
+    ) -> HRESULT,
+    fn Create(
+        Type: TASK_ACTION_TYPE,
+        ppAction: *mut *mut IAction,
+    ) -> HRESULT,
+    fn Remove(
+        index: VARIANT,
+    ) -> HRESULT,
+    fn Clear() -> HRESULT,
+    fn get_Context(
+        pContext: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Context(
+        pContext: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xbae54997, 0x48b1, 0x4cbe, 0x99, 0x65, 0xd6, 0xbe, 0x26, 0x3e, 0xbe, 0xa4)]
+interface IAction(IActionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Id(
+        pId: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Id(
+        pId: BSTR,
+    ) -> HRESULT,
+    fn get_Type(
+        pType: *mut TASK_ACTION_TYPE,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_ACTION_TYPE {
+    TASK_ACTION_EXEC = 0,
+    TASK_ACTION_COM_HANDLER = 5,
+    TASK_ACTION_SEND_EMAIL = 6,
+    TASK_ACTION_SHOW_MESSAGE = 7,
+}}
+RIDL!{#[uuid(0x86627eb4, 0x42a7, 0x41e4, 0xa4, 0xd9, 0xac, 0x33, 0xa7, 0x2f, 0x2d, 0x52)]
+interface IRegisteredTaskCollection(IRegisteredTaskCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut LONG,
+    ) -> HRESULT,
+    fn get_Item(
+        index: VARIANT,
+        ppRegisteredTask: *mut *mut IRegisteredTask,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x2faba4c7, 0x4da9, 0x4013, 0x96, 0x97, 0x20, 0xcc, 0x3f, 0xd4, 0x0f, 0x85)]
+interface ITaskService(ITaskServiceVtbl): IDispatch(IDispatchVtbl) {
+    fn GetFolder(
+        Path: BSTR,
+        ppFolder: *mut *mut ITaskFolder,
+    ) -> HRESULT,
+    fn GetRunningTasks(
+        flags: LONG,
+        ppRunningTasks: *mut *mut IRunningTaskCollection,
+    ) -> HRESULT,
+    fn NewTask(
+        flags: DWORD,
+        ppDefinition: *mut *mut ITaskDefinition,
+    ) -> HRESULT,
+    fn Connect(
+        serverName: VARIANT,
+        user: VARIANT,
+        domain: VARIANT,
+        password: VARIANT,
+    ) -> HRESULT,
+    fn get_Connected(
+        pConnected: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_TargetServer(
+        pServer: *mut BSTR,
+    ) -> HRESULT,
+    fn get_ConnectedUser(
+        pUser: *mut BSTR,
+    ) -> HRESULT,
+    fn get_ConnectedDomain(
+        pDomain: *mut BSTR,
+    ) -> HRESULT,
+    fn get_HighestVersion(
+        pVersion: *mut DWORD,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x839d7762, 0x5121, 0x4009, 0x92, 0x34, 0x4f, 0x0d, 0x19, 0x39, 0x4f, 0x04)]
+interface ITaskHandler(ITaskHandlerVtbl): IUnknown(IUnknownVtbl) {
+    fn Start(
+        pHandlerServices: LPUNKNOWN,
+        Data: BSTR,
+    ) -> HRESULT,
+    fn Stop(
+        pRetCode: *mut HRESULT,
+    ) -> HRESULT,
+    fn Pause() -> HRESULT,
+    fn Resume() -> HRESULT,
+}}
+RIDL!{#[uuid(0xeaec7a8f, 0x27a0, 0x4ddc, 0x86, 0x75, 0x14, 0x72, 0x6a, 0x01, 0xa3, 0x8a)]
+interface ITaskHandlerStatus(ITaskHandlerStatusVtbl): IUnknown(IUnknownVtbl) {
+    fn UpdateStatus(
+        percentComplete: c_short,
+        statusMessage: BSTR,
+    ) -> HRESULT,
+    fn TaskCompleted(
+        taskErrCode: HRESULT,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x3e4c9351, 0xd966, 0x4b8b, 0xbb, 0x87, 0xce, 0xba, 0x68, 0xbb, 0x01, 0x07)]
+interface ITaskVariables(ITaskVariablesVtbl): IUnknown(IUnknownVtbl) {
+    fn GetInput(
+        pInput: *mut BSTR,
+    ) -> HRESULT,
+    fn SetOutput(
+        input: BSTR,
+    ) -> HRESULT,
+    fn GetContext(
+        pContext: *mut BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x39038068, 0x2b46, 0x4afd, 0x86, 0x62, 0x7b, 0xb6, 0xf8, 0x68, 0xd2, 0x21)]
+interface ITaskNamedValuePair(ITaskNamedValuePairVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Name(
+        pName: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Name(
+        pName: BSTR,
+    ) -> HRESULT,
+    fn get_Value(
+        pValue: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Value(
+        pValue: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xb4ef826b, 0x63c3, 0x46e4, 0xa5, 0x04, 0xef, 0x69, 0xe4, 0xf7, 0xea, 0x4d)]
+interface ITaskNamedValueCollection(ITaskNamedValueCollectionVtbl): IDispatch(IDispatchVtbl) {
+    fn get_Count(
+        pCount: *mut c_long,
+    ) -> HRESULT,
+    fn get_Item(
+        index: LONG,
+        ppPair: *mut *mut ITaskNamedValuePair,
+    ) -> HRESULT,
+    fn get__NewEnum(
+        ppEnum: *mut LPUNKNOWN,
+    ) -> HRESULT,
+    fn Create(
+        Name: BSTR,
+        Value: BSTR,
+        ppPair: *mut *mut ITaskNamedValuePair,
+    ) -> HRESULT,
+    fn Remove(
+        index: LONG,
+    ) -> HRESULT,
+    fn Clear() -> HRESULT,
+}}
+RIDL!{#[uuid(0xd537d2b0, 0x9fb3, 0x4d34, 0x97, 0x39, 0x1f, 0xf5, 0xce, 0x7b, 0x1e, 0xf3)]
+interface IIdleTrigger(IIdleTriggerVtbl): ITrigger(ITriggerVtbl) {}}
+RIDL!{#[uuid(0x72dade38, 0xfae4, 0x4b3e, 0xba, 0xf4, 0x5d, 0x00, 0x9a, 0xf0, 0x2b, 0x1c)]
+interface ILogonTrigger(ILogonTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_Delay(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Delay(
+        pDelay: BSTR,
+    ) -> HRESULT,
+    fn get_UserId(
+        pUser: *mut BSTR,
+    ) -> HRESULT,
+    fn put_UserId(
+        pUser: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x754da71b, 0x4385, 0x4475, 0x9d, 0xd9, 0x59, 0x82, 0x94, 0xfa, 0x36, 0x41)]
+interface ISessionStateChangeTrigger(ISessionStateChangeTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_Delay(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Delay(
+        pDelay: BSTR,
+    ) -> HRESULT,
+    fn get_UserId(
+        pUser: *mut BSTR,
+    ) -> HRESULT,
+    fn put_UserId(
+        pUser: BSTR,
+    ) -> HRESULT,
+    fn get_StateChange(
+        pType: *mut TASK_SESSION_STATE_CHANGE_TYPE,
+    ) -> HRESULT,
+    fn put_StateChange(
+        pType: TASK_SESSION_STATE_CHANGE_TYPE,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_SESSION_STATE_CHANGE_TYPE {
+    TASK_CONSOLE_CONNECT = 1,
+    TASK_CONSOLE_DISCONNECT = 2,
+    TASK_REMOTE_CONNECT = 3,
+    TASK_REMOTE_DISCONNECT = 4,
+    TASK_SESSION_LOCK = 7,
+    TASK_SESSION_UNLOCK = 8,
+}}
+RIDL!{#[uuid(0xd45b0167, 0x9653, 0x4eef, 0xb9, 0x4f, 0x07, 0x32, 0xca, 0x7a, 0xf2, 0x51)]
+interface IEventTrigger(IEventTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_Subscription(
+        pQuery: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Subscription(
+        pQuery: BSTR,
+    ) -> HRESULT,
+    fn get_Delay(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Delay(
+        pDelay: BSTR,
+    ) -> HRESULT,
+    fn get_ValueQueries(
+        ppNamedXPaths: *mut *mut ITaskNamedValueCollection,
+    ) -> HRESULT,
+    fn put_ValueQueries(
+        ppNamedXPaths: *const ITaskNamedValueCollection,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xb45747e0, 0xeba7, 0x4276, 0x9f, 0x29, 0x85, 0xc5, 0xbb, 0x30, 0x00, 0x06)]
+interface ITimeTrigger(ITimeTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_RandomDelay(
+        pRandomDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RandomDelay(
+        pRandomDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x126c5cd8, 0xb288, 0x41d5, 0x8d, 0xbf, 0xe4, 0x91, 0x44, 0x6a, 0xdc, 0x5c)]
+interface IDailyTrigger(IDailyTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_DaysInterval(
+        pDays: *mut c_short,
+    ) -> HRESULT,
+    fn put_DaysInterval(
+        pDays: c_short,
+    ) -> HRESULT,
+    fn get_RandomDelay(
+        pRandomDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RandomDelay(
+        pRandomDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x5038fc98, 0x82ff, 0x436d, 0x87, 0x28, 0xa5, 0x12, 0xa5, 0x7c, 0x9d, 0xc1)]
+interface IWeeklyTrigger(IWeeklyTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_DaysOfWeek(
+        pDays: *mut c_short,
+    ) -> HRESULT,
+    fn put_DaysOfWeek(
+        pDays: c_short,
+    ) -> HRESULT,
+    fn get_WeeksInterval(
+        pWeeks: *mut c_short,
+    ) -> HRESULT,
+    fn put_WeeksInterval(
+        pWeeks: c_short,
+    ) -> HRESULT,
+    fn get_RandomDelay(
+        pRandomDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RandomDelay(
+        pRandomDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x97c45ef1, 0x6b02, 0x4a1a, 0x9c, 0x0e, 0x1e, 0xbf, 0xba, 0x15, 0x00, 0xac)]
+interface IMonthlyTrigger(IMonthlyTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_DaysOfMonth(
+        pDays: *mut c_long,
+    ) -> HRESULT,
+    fn put_DaysOfMonth(
+        pDays: c_long,
+    ) -> HRESULT,
+    fn get_MonthsOfYear(
+        pMonths: *mut c_short,
+    ) -> HRESULT,
+    fn put_MonthsOfYear(
+        pMonths: c_short,
+    ) -> HRESULT,
+    fn get_RunOnLastDayOfMonth(
+        pLastDay: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_RunOnLastDayOfMonth(
+        pLastDay: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_RandomDelay(
+        pRandomDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RandomDelay(
+        pRandomDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x77d025a3, 0x90fa, 0x43aa, 0xb5, 0x2e, 0xcd, 0xa5, 0x49, 0x9b, 0x94, 0x6a)]
+interface IMonthlyDOWTrigger(IMonthlyDOWTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_DaysOfWeek(
+        pDays: *mut c_short,
+    ) -> HRESULT,
+    fn put_DaysOfWeek(
+        pDays: c_short,
+    ) -> HRESULT,
+    fn get_WeeksOfMonth(
+        pWeeks: *mut c_short,
+    ) -> HRESULT,
+    fn put_WeeksOfMonth(
+        pWeeks: c_short,
+    ) -> HRESULT,
+    fn get_MonthsOfYear(
+        pMonths: *mut c_short,
+    ) -> HRESULT,
+    fn put_MonthsOfYear(
+        pMonths: c_short,
+    ) -> HRESULT,
+    fn get_RunOnLastWeekOfMonth(
+        pLastWeek: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_RunOnLastWeekOfMonth(
+        pLastWeek: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_RandomDelay(
+        pRandomDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_RandomDelay(
+        pRandomDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x2a9c35da, 0xd357, 0x41f4, 0xbb, 0xc1, 0x20, 0x7a, 0xc1, 0xb1, 0xf3, 0xcb)]
+interface IBootTrigger(IBootTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_Delay(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Delay(
+        pDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x4c8fec3a, 0xc218, 0x4e0c, 0xb2, 0x3d, 0x62, 0x90, 0x24, 0xdb, 0x91, 0xa2)]
+interface IRegistrationTrigger(IRegistrationTriggerVtbl): ITrigger(ITriggerVtbl) {
+    fn get_Delay(
+        pDelay: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Delay(
+        pDelay: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x4c3d624d, 0xfd6b, 0x49a3, 0xb9, 0xb7, 0x09, 0xcb, 0x3c, 0xd3, 0xf0, 0x47)]
+interface IExecAction(IExecActionVtbl): IAction(IActionVtbl) {
+    fn get_Path(
+        pPath: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Path(
+        pPath: BSTR,
+    ) -> HRESULT,
+    fn get_Arguments(
+        pArgument: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Arguments(
+        pArgument: BSTR,
+    ) -> HRESULT,
+    fn get_WorkingDirectory(
+        pWorkingDirectory: *mut BSTR,
+    ) -> HRESULT,
+    fn put_WorkingDirectory(
+        pWorkingDirectory: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xf2a82542, 0xbda5, 0x4e6b, 0x91, 0x43, 0xe2, 0xbf, 0x4f, 0x89, 0x87, 0xb6)]
+interface IExecAction2(IExecAction2Vtbl): IExecAction(IExecActionVtbl) {
+    fn get_HideAppWindow(
+        pHideAppWindow: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_HideAppWindow(
+        pHideAppWindow: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x505e9e68, 0xaf89, 0x46b8, 0xa3, 0x0f, 0x56, 0x16, 0x2a, 0x83, 0xd5, 0x37)]
+interface IShowMessageAction(IShowMessageActionVtbl): IAction(IActionVtbl) {
+    fn get_Title(
+        pTitle: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Title(
+        pTitle: BSTR,
+    ) -> HRESULT,
+    fn get_MessageBody(
+        pMessageBody: *mut BSTR,
+    ) -> HRESULT,
+    fn put_MessageBody(
+        pMessageBody: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x6d2fd252, 0x75c5, 0x4f66, 0x90, 0xba, 0x2a, 0x7d, 0x8c, 0xc3, 0x03, 0x9f)]
+interface IComHandlerAction(IComHandlerActionVtbl): IAction(IActionVtbl) {
+    fn get_ClassId(
+        pClsid: *mut BSTR,
+    ) -> HRESULT,
+    fn put_ClassId(
+        pClsid: BSTR,
+    ) -> HRESULT,
+    fn get_Data(
+        pData: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Data(
+        pData: BSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x10f62c64, 0x7e16, 0x4314, 0xa0, 0xc2, 0x0c, 0x36, 0x83, 0xf9, 0x9d, 0x40)]
+interface IEmailAction(IEmailActionVtbl): IAction(IActionVtbl) {
+    fn get_Server(
+        pServer: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Server(
+        pServer: BSTR,
+    ) -> HRESULT,
+    fn get_Subject(
+        pSubject: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Subject(
+        pSubject: BSTR,
+    ) -> HRESULT,
+    fn get_To(
+        pTo: *mut BSTR,
+    ) -> HRESULT,
+    fn put_To(
+        pTo: BSTR,
+    ) -> HRESULT,
+    fn get_Cc(
+        pCc: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Cc(
+        pCc: BSTR,
+    ) -> HRESULT,
+    fn get_Bcc(
+        pBcc: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Bcc(
+        pBcc: BSTR,
+    ) -> HRESULT,
+    fn get_ReplyTo(
+        pReplyTo: *mut BSTR,
+    ) -> HRESULT,
+    fn put_ReplyTo(
+        pReplyTo: BSTR,
+    ) -> HRESULT,
+    fn get_From(
+        pFrom: *mut BSTR,
+    ) -> HRESULT,
+    fn put_From(
+        pFrom: BSTR,
+    ) -> HRESULT,
+    fn get_HeaderFields(
+        ppHeaderFields: *mut *mut ITaskNamedValueCollection,
+    ) -> HRESULT,
+    fn put_HeaderFields(
+        ppHeaderFields: *const ITaskNamedValueCollection,
+    ) -> HRESULT,
+    fn get_Body(
+        pBody: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Body(
+        pBody: BSTR,
+    ) -> HRESULT,
+    fn get_Attachments(
+        pAttachements: *mut SAFEARRAY,
+    ) -> HRESULT,
+    fn put_Attachments(
+        pAttachements: SAFEARRAY,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x248919ae, 0xe345, 0x4a6d, 0x8a, 0xeb, 0xe0, 0xd3, 0x16, 0x5c, 0x90, 0x4e)]
+interface IPrincipal2(IPrincipal2Vtbl): IDispatch(IDispatchVtbl) {
+    fn get_ProcessTokenSidType(
+        pProcessTokenSidType: *mut TASK_PROCESSTOKENSID,
+    ) -> HRESULT,
+    fn put_ProcessTokenSidType(
+        pProcessTokenSidType: TASK_PROCESSTOKENSID,
+    ) -> HRESULT,
+    fn get_RequiredPrivilegeCount(
+        pCount: *mut c_long,
+    ) -> HRESULT,
+    fn get_RequiredPrivilege(
+        index: c_long,
+        pPrivilege: *mut BSTR,
+    ) -> HRESULT,
+    fn AddRequiredPrivilege(
+        privilege: BSTR,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_PROCESSTOKENSID {
+    TASK_PROCESSTOKENSID_NONE = 0,
+    TASK_PROCESSTOKENSID_UNRESTRICTED = 1,
+    TASK_PROCESSTOKENSID_DEFAULT = 2,
+}}
+RIDL!{#[uuid(0x2c05c3f0, 0x6eed, 0x4c05, 0xa1, 0x5f, 0xed, 0x7d, 0x7a, 0x98, 0xa3, 0x69)]
+interface ITaskSettings2(ITaskSettings2Vtbl): IDispatch(IDispatchVtbl) {
+    fn get_DisallowStartOnRemoteAppSession(
+        pDisallowStart: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_DisallowStartOnRemoteAppSession(
+        pDisallowStart: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_UseUnifiedSchedulingEngine(
+        pUseUnifiedEngine: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_UseUnifiedSchedulingEngine(
+        pUseUnifiedEngine: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x0ad9d0d7, 0x0c7f, 0x4ebb, 0x9a, 0x5f, 0xd1, 0xc6, 0x48, 0xdc, 0xa5, 0x28)]
+interface ITaskSettings3(ITaskSettings3Vtbl): ITaskSettings(ITaskSettingsVtbl) {
+    fn get_DisallowStartOnRemoteAppSession(
+        pDisallowStart: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_DisallowStartOnRemoteAppSession(
+        pDisallowStart: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_UseUnifiedSchedulingEngine(
+        pUseUnifiedEngine: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_UseUnifiedSchedulingEngine(
+        pUseUnifiedEngine: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_MaintenanceSettings(
+        ppMaintenanceSettings: *mut *mut IMaintenanceSettings,
+    ) -> HRESULT,
+    fn put_MaintenanceSettings(
+        ppMaintenanceSettings: *const IMaintenanceSettings,
+    ) -> HRESULT,
+    fn CreateMaintenanceSettings(
+        ppMaintenanceSettings: *mut *mut IMaintenanceSettings,
+    ) -> HRESULT,
+    fn get_Volatile(
+        pVolatile: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+    fn put_Volatile(
+        pVolatile: VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xa6024fa8, 0x9652, 0x4adb, 0xa6, 0xbf, 0x5c, 0xfc, 0xd8, 0x77, 0xa7, 0xba)]
+interface IMaintenanceSettings(IMaintenanceSettingsVtbl): IDispatch(IDispatchVtbl) {
+    fn put_Period(
+        target: BSTR,
+    ) -> HRESULT,
+    fn get_Period(
+        target: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Deadline(
+        target: BSTR,
+    ) -> HRESULT,
+    fn get_Deadline(
+        target: *mut BSTR,
+    ) -> HRESULT,
+    fn put_Exclusive(
+        target: VARIANT_BOOL,
+    ) -> HRESULT,
+    fn get_Exclusive(
+        target: *mut VARIANT_BOOL,
+    ) -> HRESULT,
+}}
+ENUM!{enum TASK_RUN_FLAGS {
+    TASK_RUN_NO_FLAGS = 0,
+    TASK_RUN_AS_SELF = 1,
+    TASK_RUN_IGNORE_CONSTRAINTS = 2,
+    TASK_RUN_USE_SESSION_ID = 4,
+    TASK_RUN_USER_SID = 8,
+}}
+ENUM!{enum TASK_ENUM_FLAGS {
+    TASK_ENUM_HIDDEN = 1,
+}}
+ENUM!{enum TASK_CREATION {
+    TASK_VALIDATE_ONLY = 1,
+    TASK_CREATE = 2,
+    TASK_UPDATE = 4,
+    TASK_CREATE_OR_UPDATE = 6,
+    TASK_DISABLE = 8,
+    TASK_DONT_ADD_PRINCIPAL_ACE = 16,
+    TASK_IGNORE_REGISTRATION_TRIGGERS = 32,
+}}