vendor/winapi/src/um/objidlbase.rs

   1 // Licensed under the Apache License, Version 2.0
   2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   4 // All files in the project carrying such notice may not be copied, modified, or distributed
   5 // except according to those terms.
   6 use ctypes::{c_int, c_void};
   7 use shared::basetsd::{SIZE_T, ULONG_PTR};
   8 use shared::guiddef::{CLSID, GUID, IID, REFCLSID, REFGUID, REFIID};
   9 use shared::minwindef::{BOOL, BYTE, DWORD, FILETIME, ULONG};
  10 use shared::wtypesbase::{COAUTHINFO, DOUBLE, LPOLESTR, OLECHAR};
  11 use um::unknwnbase::{IUnknown, IUnknownVtbl};
  12 use um::winnt::{HANDLE, HRESULT, LARGE_INTEGER, LONG, LPWSTR, ULARGE_INTEGER};
  13 STRUCT!{struct COSERVERINFO {
  14     dwReserved1: DWORD,
  15     pwszName: LPWSTR,
  16     pAuthInfo: *mut COAUTHINFO,
  17     dwReserved2: DWORD,
  18 }}
  19 pub type LPMARSHAL = *mut IMarshal;
  20 RIDL!{#[uuid(0x00000003, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
  21 interface IMarshal(IMarshalVtbl): IUnknown(IUnknownVtbl) {
  22     fn GetUnmarshalClass(
  23         riid: REFIID,
  24         pv: *mut c_void,
  25         dwDestContext: DWORD,
  26         pvDestContext: *mut c_void,
  27         mshlflags: DWORD,
  28         pCid: *mut CLSID,
  29     ) -> HRESULT,
  30     fn GetMarshalSizeMax(
  31         riid: REFIID,
  32         pv: *mut c_void,
  33         dwDestContext: DWORD,
  34         pvDestContext: *mut c_void,
  35         mshlflags: DWORD,
  36         pSize: *mut DWORD,
  37     ) -> HRESULT,
  38     fn MarshalInterface(
  39         pStm: *mut IStream,
  40         riid: REFIID,
  41         pv: *mut c_void,
  42         dwDestContext: DWORD,
  43         pvDestContext: *mut c_void,
  44         mshlflags: DWORD,
  45     ) -> HRESULT,
  46     fn UnmarshalInterface(
  47         pStm: *mut IStream,
  48         riid: REFIID,
  49         ppv: *mut *mut c_void,
  50     ) -> HRESULT,
  51     fn ReleaseMarshalData(
  52         pStm: *mut IStream,
  53     ) -> HRESULT,
  54     fn DisconnectObject(
  55         dwReserved: DWORD,
  56     ) -> HRESULT,
  57 }}
  58 RIDL!{#[uuid(0xecc8691b, 0xc1db, 0x4dc0, 0x85, 0x5e, 0x65, 0xf6, 0xc5, 0x51, 0xaf, 0x49)]
  59 interface INoMarshal(INoMarshalVtbl): IUnknown(IUnknownVtbl) {}}
  60 RIDL!{#[uuid(0x94ea2b94, 0xe9cc, 0x49e0, 0xc0, 0xff, 0xee, 0x64, 0xca, 0x8f, 0x5b, 0x90)]
  61 interface IAgileObject(IAgileObjectVtbl): IUnknown(IUnknownVtbl) {}}
  62 ENUM!{enum ACTIVATIONTYPE {
  63     ACTIVATIONTYPE_UNCATEGORIZED = 0,
  64     ACTIVATIONTYPE_FROM_MONIKER = 0x1,
  65     ACTIVATIONTYPE_FROM_DATA = 0x2,
  66     ACTIVATIONTYPE_FROM_STORAGE = 0x4,
  67     ACTIVATIONTYPE_FROM_STREAM = 0x8,
  68     ACTIVATIONTYPE_FROM_FILE = 0x10,
  69 }}
  70 RIDL!{#[uuid(0x00000017, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
  71 interface IActivationFilter(IActivationFilterVtbl): IUnknown(IUnknownVtbl) {
  72     fn HandleActivation(
  73         dwActivationType: DWORD,
  74         rclsid: REFCLSID,
  75         pReplacementClsId: *mut CLSID,
  76     ) -> HRESULT,
  77 }}
  78 pub type LPMARSHAL2 = *mut IMarshal2;
  79 RIDL!{#[uuid(0x000001cf, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
  80 interface IMarshal2(IMarshal2Vtbl): IMarshal(IMarshalVtbl) {}}
  81 pub type LPMALLOC = *mut IMalloc;
  82 RIDL!{#[uuid(0x00000002, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
  83 interface IMalloc(IMallocVtbl): IUnknown(IUnknownVtbl) {
  84     fn Alloc(
  85         cb: SIZE_T,
  86     ) -> *mut c_void,
  87     fn Realloc(
  88         pv: *mut c_void,
  89         cb: SIZE_T,
  90     ) -> *mut c_void,
  91     fn Free(
  92         pv: *mut c_void,
  93     ) -> (),
  94     fn GetSize(
  95         pv: *mut c_void,
  96     ) -> SIZE_T,
  97     fn DidAlloc(
  98         pv: *mut c_void,
  99     ) -> c_int,
 100     fn HeapMinimize() -> (),
 101 }}
 102 pub type LPSTDMARSHALINFO = IStdMarshalInfo;
 103 RIDL!{#[uuid(0x00000018, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 104 interface IStdMarshalInfo(IStdMarshalInfoVtbl): IUnknown(IUnknownVtbl) {
 105     fn GetClassForHandler(
 106         dwDestContext: DWORD,
 107         pvDestContext: *mut c_void,
 108         pClsid: *mut CLSID,
 109     ) -> HRESULT,
 110 }}
 111 ENUM!{enum EXTCONN {
 112     EXTCONN_STRONG = 0x1,
 113     EXTCONN_WEAK = 0x2,
 114     EXTCONN_CALLABLE = 0x4,
 115 }}
 116 RIDL!{#[uuid(0x00000019, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 117 interface IExternalConnection(IExternalConnectionVtbl): IUnknown(IUnknownVtbl) {
 118     fn AddConnection(
 119         extconn: DWORD,
 120         reserved: DWORD,
 121     ) -> DWORD,
 122     fn ReleaseConnection(
 123         extconn: DWORD,
 124         reserved: DWORD,
 125         fLastReleaseCloses: BOOL,
 126     ) -> DWORD,
 127 }}
 128 pub type LPMULTIQI = *mut IMultiQI;
 129 STRUCT!{struct MULTI_QI {
 130     pIID: *const IID,
 131     pItf: *mut IUnknown,
 132     hr: HRESULT,
 133 }}
 134 RIDL!{#[uuid(0x00000020, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 135 interface IMultiQI(IMultiQIVtbl): IUnknown(IUnknownVtbl) {
 136     fn QueryMultipleInterfaces(
 137         cMQIs: ULONG,
 138         pMQIs: *mut MULTI_QI,
 139     ) -> HRESULT,
 140 }}
 141 RIDL!{#[uuid(0x000e0020, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 142 interface AsyncIMultiQI(AsyncIMultiQIVtbl): IUnknown(IUnknownVtbl) {
 143     fn Begin_QueryMultipleInterfaces(
 144         cMQIs: ULONG,
 145         pMQIs: *mut MULTI_QI,
 146     ) -> HRESULT,
 147     fn Finish_QueryMultipleInterfaces(
 148         pMQIs: *mut MULTI_QI,
 149     ) -> HRESULT,
 150 }}
 151 RIDL!{#[uuid(0x00000021, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 152 interface IInternalUnknown(IInternalUnknownVtbl): IUnknown(IUnknownVtbl) {
 153     fn QueryInternalInterface(
 154         riid: REFIID,
 155         ppv: *mut *mut c_void,
 156     ) -> HRESULT,
 157 }}
 158 RIDL!{#[uuid(0x00000100, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 159 interface IEnumUnknown(IEnumUnknownVtbl): IUnknown(IUnknownVtbl) {
 160     fn Next(
 161         celt: ULONG,
 162         rgelt: *mut *mut IUnknown,
 163         pceltFetched: *mut ULONG,
 164     ) -> HRESULT,
 165     fn Skip(
 166         celt: ULONG,
 167     ) -> HRESULT,
 168     fn Reset() -> HRESULT,
 169     fn Clone(
 170         ppenum: *mut *mut IEnumUnknown,
 171     ) -> HRESULT,
 172 }}
 173 RIDL!{#[uuid(0x00000101, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 174 interface IEnumString(IEnumStringVtbl): IUnknown(IUnknownVtbl) {
 175     fn Next(
 176         celt: ULONG,
 177         rgelt: *mut LPOLESTR,
 178         pceltFetched: *mut ULONG,
 179     ) -> HRESULT,
 180     fn Skip(
 181         celt: ULONG,
 182     ) -> HRESULT,
 183     fn Reset() -> HRESULT,
 184     fn Clone(
 185         ppenum: *mut *mut IEnumString,
 186     ) -> HRESULT,
 187 }}
 188 RIDL!{#[uuid(0x0c733a30, 0x2a1c, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d)]
 189 interface ISequentialStream(ISequentialStreamVtbl): IUnknown(IUnknownVtbl) {
 190     fn Read(
 191         pv: *mut c_void,
 192         cb: ULONG,
 193         pcbRead: *mut ULONG,
 194     ) -> HRESULT,
 195     fn Write(
 196         pv: *const c_void,
 197         cb: ULONG,
 198         pcbWritten: *mut ULONG,
 199     ) -> HRESULT,
 200 }}
 201 STRUCT!{struct STATSTG {
 202     pwcsName: LPOLESTR,
 203     type_: DWORD,
 204     cbSize: ULARGE_INTEGER,
 205     mtime: FILETIME,
 206     ctime: FILETIME,
 207     atime: FILETIME,
 208     grfMode: DWORD,
 209     grfLocksSupported: DWORD,
 210     clsid: CLSID,
 211     grfStateBits: DWORD,
 212     reserved: DWORD,
 213 }}
 214 ENUM!{enum STGTY {
 215     STGTY_STORAGE = 1,
 216     STGTY_STREAM = 2,
 217     STGTY_LOCKBYTES = 3,
 218     STGTY_PROPERTY = 4,
 219 }}
 220 ENUM!{enum STREAM_SEEK {
 221     STREAM_SEEK_SET = 0,
 222     STREAM_SEEK_CUR = 1,
 223     STREAM_SEEK_END = 2,
 224 }}
 225 ENUM!{enum LOCKTYPE {
 226     LOCK_WRITE = 1,
 227     LOCK_EXCLUSIVE = 2,
 228     LOCK_ONLYONCE = 4,
 229 }}
 230 pub type LPSTREAM = *mut IStream;
 231 RIDL!{#[uuid(0x0000000c, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 232 interface IStream(IStreamVtbl): ISequentialStream(ISequentialStreamVtbl) {
 233     fn Seek(
 234         dlibMove: LARGE_INTEGER,
 235         dwOrigin: DWORD,
 236         plibNewPosition: *mut ULARGE_INTEGER,
 237     ) -> HRESULT,
 238     fn SetSize(
 239         libNewSize: ULARGE_INTEGER,
 240     ) -> HRESULT,
 241     fn CopyTo(
 242         pstm: *mut IStream,
 243         cb: ULARGE_INTEGER,
 244         pcbRead: *mut ULARGE_INTEGER,
 245         pcbWritten: *mut ULARGE_INTEGER,
 246     ) -> HRESULT,
 247     fn Commit(
 248         grfCommitFlags: DWORD,
 249     ) -> HRESULT,
 250     fn Revert() -> HRESULT,
 251     fn LockRegion(
 252         libOffset: ULARGE_INTEGER,
 253         cb: ULARGE_INTEGER,
 254         dwLockType: DWORD,
 255     ) -> HRESULT,
 256     fn UnlockRegion(
 257         libOffset: ULARGE_INTEGER,
 258         cb: ULARGE_INTEGER,
 259         dwLockType: DWORD,
 260     ) -> HRESULT,
 261     fn Stat(
 262         pstatstg: *mut STATSTG,
 263         grfStatFlag: DWORD,
 264     ) -> HRESULT,
 265     fn Clone(
 266         ppstm: *mut *mut IStream,
 267     ) -> HRESULT,
 268 }}
 269 pub type RPCOLEDATAREP = ULONG;
 270 STRUCT!{struct RPCOLEMESSAGE {
 271     reserved1: *mut c_void,
 272     dataRepresentation: RPCOLEDATAREP,
 273     Buffer: *mut c_void,
 274     cbBuffer: ULONG,
 275     iMethod: ULONG,
 276     reserved2: [*mut c_void; 5],
 277     rpcFlags: ULONG,
 278 }}
 279 pub type PRPCOLEMESSAGE = *mut RPCOLEMESSAGE;
 280 RIDL!{#[uuid(0xd5f56b60, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
 281 interface IRpcChannelBuffer(IRpcChannelBufferVtbl): IUnknown(IUnknownVtbl) {
 282     fn GetBuffer(
 283         pMessage: *mut RPCOLEMESSAGE,
 284         riid: REFIID,
 285     ) -> HRESULT,
 286     fn SendReceive(
 287         pMessage: *mut RPCOLEMESSAGE,
 288         pStatus: *mut ULONG,
 289     ) -> HRESULT,
 290     fn FreeBuffer(
 291         pMessage: *mut RPCOLEMESSAGE,
 292     ) -> HRESULT,
 293     fn GetDestCtx(
 294         pdwDestContext: *mut DWORD,
 295         ppvDestContext: *mut *mut c_void,
 296     ) -> HRESULT,
 297     fn IsConnected() -> HRESULT,
 298 }}
 299 RIDL!{#[uuid(0x594f31d0, 0x7f19, 0x11d0, 0xb1, 0x94, 0x00, 0xa0, 0xc9, 0x0d, 0xc8, 0xbf)]
 300 interface IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl): IRpcChannelBuffer(IRpcChannelBufferVtbl) {
 301     fn GetProtocolVersion(
 302         pdwVersion: *mut DWORD,
 303     ) -> HRESULT,
 304 }}
 305 RIDL!{#[uuid(0xa5029fb6, 0x3c34, 0x11d1, 0x9c, 0x99, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0xaa)]
 306 interface IAsyncRpcChannelBuffer(IAsyncRpcChannelBufferVtbl):
 307     IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl) {
 308     fn Send(
 309         pMsg: *mut RPCOLEMESSAGE,
 310         pSync: *mut ISynchronize,
 311         pulStatus: *mut ULONG,
 312     ) -> HRESULT,
 313     fn Receive(
 314         pMsg: *mut RPCOLEMESSAGE,
 315         pulStatus: *mut ULONG,
 316     ) -> HRESULT,
 317     fn GetDestCtxEx(
 318         pMsg: *mut RPCOLEMESSAGE,
 319         pdwDestContext: *mut DWORD,
 320         ppvDestContext: *mut *mut c_void,
 321     ) -> HRESULT,
 322 }}
 323 RIDL!{#[uuid(0x25b15600, 0x0115, 0x11d0, 0xbf, 0x0d, 0x00, 0xaa, 0x00, 0xb8, 0xdf, 0xd2)]
 324 interface IRpcChannelBuffer3(IRpcChannelBuffer3Vtbl): IRpcChannelBuffer2(IRpcChannelBuffer2Vtbl) {
 325     fn Send(
 326         pMsg: *mut RPCOLEMESSAGE,
 327         pulStatus: *mut ULONG,
 328     ) -> HRESULT,
 329     fn Receive(
 330         pMsg: *mut RPCOLEMESSAGE,
 331         ulSize: ULONG,
 332         pulStatus: *mut ULONG,
 333     ) -> HRESULT,
 334     fn Cancel(
 335         pMsg: *mut RPCOLEMESSAGE,
 336     ) -> HRESULT,
 337     fn GetCallContext(
 338         pMsg: *mut RPCOLEMESSAGE,
 339         riid: REFIID,
 340         pInterface: *mut *mut c_void,
 341     ) -> HRESULT,
 342     fn GetDestCtxEx(
 343         pMsg: *mut RPCOLEMESSAGE,
 344         pdwDestContext: *mut DWORD,
 345         ppvDestContext: *mut *mut c_void,
 346     ) -> HRESULT,
 347     fn GetState(
 348         pMsg: *mut RPCOLEMESSAGE,
 349         pState: *mut DWORD,
 350     ) -> HRESULT,
 351     fn RegisterAsync(
 352         pMsg: *mut RPCOLEMESSAGE,
 353         pAsyncMgr: *mut IAsyncManager,
 354     ) -> HRESULT,
 355 }}
 356 RIDL!{#[uuid(0x58a08519, 0x24c8, 0x4935, 0xb4, 0x82, 0x3f, 0xd8, 0x23, 0x33, 0x3a, 0x4f)]
 357 interface IRpcSyntaxNegotiate(IRpcSyntaxNegotiateVtbl): IUnknown(IUnknownVtbl) {
 358     fn NegotiateSyntax(
 359         pMsg: *mut RPCOLEMESSAGE,
 360     ) -> HRESULT,
 361 }}
 362 RIDL!{#[uuid(0xd5f56a34, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
 363 interface IRpcProxyBuffer(IRpcProxyBufferVtbl): IUnknown(IUnknownVtbl) {
 364     fn Connect(
 365         pRpcChannelBuffer: *mut IRpcChannelBuffer,
 366     ) -> HRESULT,
 367     fn Disconnect() -> (),
 368 }}
 369 RIDL!{#[uuid(0xd5f56afc, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
 370 interface IRpcStubBuffer(IRpcStubBufferVtbl): IUnknown(IUnknownVtbl) {
 371     fn Connect(
 372         pUnkServer: *mut IUnknown,
 373     ) -> HRESULT,
 374     fn Disconnect() -> (),
 375     fn Invoke(
 376         _prpcmsg: *mut RPCOLEMESSAGE,
 377         _pRpcChannelBuffer: *mut IRpcChannelBuffer,
 378     ) -> HRESULT,
 379     fn IsIIDSupported(
 380         riid: REFIID,
 381     ) -> *mut IRpcStubBuffer,
 382     fn CountRefs() -> ULONG,
 383     fn DebugServerQueryInterface(
 384         ppv: *mut *mut c_void,
 385     ) -> HRESULT,
 386     fn DebugServerRelease(
 387         pv: *mut c_void,
 388     ) -> (),
 389 }}
 390 RIDL!{#[uuid(0xd5f569d0, 0x593b, 0x101a, 0xb5, 0x69, 0x08, 0x00, 0x2b, 0x2d, 0xbf, 0x7a)]
 391 interface IPSFactoryBuffer(IPSFactoryBufferVtbl): IUnknown(IUnknownVtbl) {
 392     fn CreateProxy(
 393         pUnkOuter: *mut IUnknown,
 394         riid: REFIID,
 395         ppProxy: *mut *mut IRpcProxyBuffer,
 396         ppv: *mut *mut c_void,
 397     ) -> HRESULT,
 398     fn CreateStub(
 399         riid: REFIID,
 400         pUnkServer: *mut *mut IUnknown,
 401         ppStub: *mut *mut IRpcStubBuffer,
 402     ) -> HRESULT,
 403 }}
 404 STRUCT!{struct SChannelHookCallInfo {
 405     iid: IID,
 406     cbSize: DWORD,
 407     uCausality: GUID,
 408     dwServerPid: DWORD,
 409     iMethod: DWORD,
 410     pObject: *mut c_void,
 411 }}
 412 RIDL!{#[uuid(0x1008c4a0, 0x7613, 0x11cf, 0x9a, 0xf1, 0x00, 0x20, 0xaf, 0x6e, 0x72, 0xf4)]
 413 interface IChannelHook(IChannelHookVtbl): IUnknown(IUnknownVtbl) {
 414     fn ClientGetSize(
 415         uExtent: REFGUID,
 416         riid: REFIID,
 417         pDataSize: *mut ULONG,
 418     ) -> (),
 419     fn ClientFillBuffer(
 420         uExtent: REFGUID,
 421         riid: REFIID,
 422         pDataSize: *mut ULONG,
 423         pDataBuffer: *mut c_void,
 424     ) -> (),
 425     fn ClientNotify(
 426         uExtent: REFGUID,
 427         riid: REFIID,
 428         cbDataSize: ULONG,
 429         pDataBuffer: *mut c_void,
 430         lDataRep: DWORD,
 431         hrFault: HRESULT,
 432     ) -> (),
 433     fn ServerNotify(
 434         uExtent: REFGUID,
 435         riid: REFIID,
 436         cbDataSize: ULONG,
 437         pDataBuffer: *mut c_void,
 438         lDataRep: DWORD,
 439     ) -> (),
 440     fn ServerGetSize(
 441         uExtent: REFGUID,
 442         riid: REFIID,
 443         hrFault: HRESULT,
 444         pDataSize: *mut ULONG,
 445     ) -> (),
 446     fn ServerFillBuffer(
 447         uExtent: REFGUID,
 448         riid: REFIID,
 449         pDataSize: *mut ULONG,
 450         pDataBuffer: *mut c_void,
 451         hrFault: HRESULT,
 452     ) -> (),
 453 }}
 454 STRUCT!{struct SOLE_AUTHENTICATION_SERVICE {
 455     dwAuthnSvc: DWORD,
 456     dwAuthzSvc: DWORD,
 457     pPrincipalName: *mut OLECHAR,
 458     hr: HRESULT,
 459 }}
 460 pub type PSOLE_AUTHENTICATION_SERVICE = *mut SOLE_AUTHENTICATION_SERVICE;
 461 ENUM!{enum EOLE_AUTHENTICATION_CAPABILITIES {
 462     EOAC_NONE = 0,
 463     EOAC_MUTUAL_AUTH = 0x1,
 464     EOAC_STATIC_CLOAKING = 0x20,
 465     EOAC_DYNAMIC_CLOAKING = 0x40,
 466     EOAC_ANY_AUTHORITY = 0x80,
 467     EOAC_MAKE_FULLSIC = 0x100,
 468     EOAC_DEFAULT = 0x800,
 469     EOAC_SECURE_REFS = 0x2,
 470     EOAC_ACCESS_CONTROL = 0x4,
 471     EOAC_APPID = 0x8,
 472     EOAC_DYNAMIC = 0x10,
 473     EOAC_REQUIRE_FULLSIC = 0x200,
 474     EOAC_AUTO_IMPERSONATE = 0x400,
 475     EOAC_DISABLE_AAA = 0x1000,
 476     EOAC_NO_CUSTOM_MARSHAL = 0x2000,
 477     EOAC_RESERVED1 = 0x4000,
 478 }}
 479 pub const COLE_DEFAULT_PRINCIPAL: *mut OLECHAR = -1isize as *mut OLECHAR;
 480 pub const COLE_DEFAULT_AUTHINFO: *mut c_void = -1isize as *mut c_void;
 481 STRUCT!{struct SOLE_AUTHENTICATION_INFO {
 482     dwAuthnSvc: DWORD,
 483     dwAuthzSvc: DWORD,
 484     pAuthInfo: *mut c_void,
 485 }}
 486 pub type PSOLE_AUTHENTICATION_INFO = *mut SOLE_AUTHENTICATION_INFO;
 487 STRUCT!{struct SOLE_AUTHENTICATION_LIST {
 488     cAuthInfo: DWORD,
 489     aAuthInfo: *mut SOLE_AUTHENTICATION_INFO,
 490 }}
 491 pub type PSOLE_AUTHENTICATION_LIST = *mut SOLE_AUTHENTICATION_LIST;
 492 RIDL!{#[uuid(0x0000013d, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 493 interface IClientSecurity(IClientSecurityVtbl): IUnknown(IUnknownVtbl) {
 494     fn QueryBlanket(
 495         pProxy: *mut IUnknown,
 496         pAuthnSvc: *mut DWORD,
 497         pAuthzSvc: *mut DWORD,
 498         pServerPrincName: *mut *mut OLECHAR,
 499         pAuthnLevel: *mut DWORD,
 500         pImpLevel: *mut DWORD,
 501         pAuthInfo: *mut *mut c_void,
 502         pCapabilities: *mut DWORD,
 503     ) -> HRESULT,
 504     fn SetBlanket(
 505         pProxy: *mut IUnknown,
 506         dwAuthnSvc: DWORD,
 507         dwAuthzSvc: DWORD,
 508         pServerPrincName: *mut OLECHAR,
 509         dwAuthnLevel: DWORD,
 510         dwImpLevel: DWORD,
 511         pAuthInfo: *mut c_void,
 512         dwCapabilities: DWORD,
 513     ) -> HRESULT,
 514     fn CopyProxy(
 515         pProxy: *mut IUnknown,
 516         ppCopy: *mut *mut IUnknown,
 517     ) -> HRESULT,
 518 }}
 519 RIDL!{#[uuid(0x0000013e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 520 interface IServerSecurity(IServerSecurityVtbl): IUnknown(IUnknownVtbl) {
 521     fn QueryBlanket(
 522         pAuthnSvc: *mut DWORD,
 523         pAuthzSvc: *mut DWORD,
 524         pServerPrincName: *mut *mut OLECHAR,
 525         pAuthnLevel: *mut DWORD,
 526         pImpLevel: *mut DWORD,
 527         pPrivs: *mut *mut c_void,
 528         pCapabilities: *mut DWORD,
 529     ) -> HRESULT,
 530     fn ImpersonateClient() -> HRESULT,
 531     fn RevertToSelf() -> HRESULT,
 532     fn IsImpersonating() -> BOOL,
 533 }}
 534 ENUM!{enum RPCOPT_PROPERTIES {
 535     COMBND_RPCTIMEOUT = 0x1,
 536     COMBND_SERVER_LOCALITY = 0x2,
 537     COMBND_RESERVED1 = 0x4,
 538     COMBND_RESERVED2 = 0x5,
 539     COMBND_RESERVED3 = 0x8,
 540     COMBND_RESERVED4 = 0x10,
 541 }}
 542 ENUM!{enum RPCOPT_SERVER_LOCALITY_VALUES {
 543     SERVER_LOCALITY_PROCESS_LOCAL = 0,
 544     SERVER_LOCALITY_MACHINE_LOCAL = 1,
 545     SERVER_LOCALITY_REMOTE = 2,
 546 }}
 547 RIDL!{#[uuid(0x00000144, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 548 interface IRpcOptions(IRpcOptionsVtbl): IUnknown(IUnknownVtbl) {
 549     fn Set(
 550         pPrx: *mut IUnknown,
 551         dwProperty: RPCOPT_PROPERTIES,
 552         dwValue: ULONG_PTR,
 553     ) -> HRESULT,
 554     fn Query(
 555         pPrx: *mut IUnknown,
 556         dwProperty: RPCOPT_PROPERTIES,
 557         pdwValue: *mut ULONG_PTR,
 558     ) -> HRESULT,
 559 }}
 560 ENUM!{enum GLOBALOPT_PROPERTIES {
 561     COMGLB_EXCEPTION_HANDLING = 1,
 562     COMGLB_APPID = 2,
 563     COMGLB_RPC_THREADPOOL_SETTING = 3,
 564     COMGLB_RO_SETTINGS = 4,
 565     COMGLB_UNMARSHALING_POLICY = 5,
 566     COMGLB_PROPERTIES_RESERVED1 = 6,
 567 }}
 568 ENUM!{enum GLOBALOPT_EH_VALUES {
 569     COMGLB_EXCEPTION_HANDLE = 0,
 570     COMGLB_EXCEPTION_DONOT_HANDLE_FATAL = 1,
 571     COMGLB_EXCEPTION_DONOT_HANDLE = COMGLB_EXCEPTION_DONOT_HANDLE_FATAL,
 572     COMGLB_EXCEPTION_DONOT_HANDLE_ANY = 2,
 573 }}
 574 ENUM!{enum GLOBALOPT_RPCTP_VALUES {
 575     COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL = 0,
 576     COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL = 1,
 577 }}
 578 ENUM!{enum GLOBALOPT_RO_FLAGS {
 579     COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES = 0x1,
 580     COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES = 0x2,
 581     COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES = 0x4,
 582     COMGLB_FAST_RUNDOWN = 0x8,
 583     COMGLB_RESERVED1 = 0x10,
 584     COMGLB_RESERVED2 = 0x20,
 585     COMGLB_RESERVED3 = 0x40,
 586     COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES = 0x80,
 587     COMGLB_RESERVED4 = 0x100,
 588     COMGLB_RESERVED5 = 0x200,
 589     COMGLB_RESERVED6 = 0x400,
 590 }}
 591 ENUM!{enum GLOBALOPT_UNMARSHALING_POLICY_VALUES {
 592     COMGLB_UNMARSHALING_POLICY_NORMAL = 0,
 593     COMGLB_UNMARSHALING_POLICY_STRONG = 1,
 594     COMGLB_UNMARSHALING_POLICY_HYBRID = 2,
 595 }}
 596 RIDL!{#[uuid(0x0000015b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 597 interface IGlobalOptions(IGlobalOptionsVtbl): IUnknown(IUnknownVtbl) {
 598     fn Set(
 599         dwProperty: GLOBALOPT_PROPERTIES,
 600         dwValue: ULONG_PTR,
 601     ) -> HRESULT,
 602     fn Query(
 603         dwProperty: GLOBALOPT_PROPERTIES,
 604         pdwValue: *mut ULONG_PTR,
 605     ) -> HRESULT,
 606 }}
 607 pub type LPSURROGATE = *mut ISurrogate;
 608 RIDL!{#[uuid(0x00000022, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 609 interface ISurrogate(ISurrogateVtbl): IUnknown(IUnknownVtbl) {
 610     fn LoadDllServer(
 611         Clsid: REFCLSID,
 612     ) -> HRESULT,
 613     fn FreeSurrogate() -> HRESULT,
 614 }}
 615 pub type LPGLOBALINTERFACETABLE = *mut IGlobalInterfaceTable;
 616 RIDL!{#[uuid(0x00000146, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 617 interface IGlobalInterfaceTable(IGlobalInterfaceTableVtbl): IUnknown(IUnknownVtbl) {
 618     fn RegisterInterfaceInGlobal(
 619         pUnk: *mut IUnknown,
 620         riid: REFIID,
 621         pdwCookie: *mut DWORD,
 622     ) -> HRESULT,
 623     fn RevokeInterfaceFromGlobal(
 624         dwCookie: DWORD,
 625     ) -> HRESULT,
 626     fn GetInterfaceFromGlobal(
 627         dwCookie: DWORD,
 628         riid: REFIID,
 629         ppv: *mut *mut c_void,
 630     ) -> HRESULT,
 631 }}
 632 RIDL!{#[uuid(0x00000030, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 633 interface ISynchronize(ISynchronizeVtbl): IUnknown(IUnknownVtbl) {
 634     fn Wait(
 635         dwFlags: DWORD,
 636         dwMilliseconds: DWORD,
 637     ) -> HRESULT,
 638     fn Signal() -> HRESULT,
 639     fn Reset() -> HRESULT,
 640 }}
 641 RIDL!{#[uuid(0x00000031, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 642 interface ISynchronizeHandle(ISynchronizeHandleVtbl): IUnknown(IUnknownVtbl) {
 643     fn GetHandle(
 644         ph: *mut HANDLE,
 645     ) -> HRESULT,
 646 }}
 647 RIDL!{#[uuid(0x00000032, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 648 interface ISynchronizeEvent(ISynchronizeEventVtbl): ISynchronizeHandle(ISynchronizeHandleVtbl) {
 649     fn SetEventHandle(
 650         ph: *mut HANDLE,
 651     ) -> HRESULT,
 652 }}
 653 RIDL!{#[uuid(0x00000033, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 654 interface ISynchronizeContainer(ISynchronizeContainerVtbl): IUnknown(IUnknownVtbl) {
 655     fn AddSynchronize(
 656         pSync: *mut ISynchronize,
 657     ) -> HRESULT,
 658     fn WaitMultiple(
 659         dwFlags: DWORD,
 660         dwTimeOut: DWORD,
 661         ppSync: *mut *mut ISynchronize,
 662     ) -> HRESULT,
 663 }}
 664 RIDL!{#[uuid(0x00000025, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 665 interface ISynchronizeMutex(ISynchronizeMutexVtbl): ISynchronize(ISynchronizeVtbl) {
 666     fn ReleaseMutex() -> HRESULT,
 667 }}
 668 pub type LPCANCELMETHODCALLS = *mut ICancelMethodCalls;
 669 RIDL!{#[uuid(0x00000029, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 670 interface ICancelMethodCalls(ICancelMethodCallsVtbl): IUnknown(IUnknownVtbl) {
 671     fn Cancel(
 672         ulSeconds: ULONG,
 673     ) -> HRESULT,
 674     fn TestCancel() -> HRESULT,
 675 }}
 676 ENUM!{enum DCOM_CALL_STATE {
 677     DCOM_NONE = 0,
 678     DCOM_CALL_COMPLETE = 0x1,
 679     DCOM_CALL_CANCELED = 0x2,
 680 }}
 681 RIDL!{#[uuid(0x0000002a, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 682 interface IAsyncManager(IAsyncManagerVtbl): IUnknown(IUnknownVtbl) {
 683     fn CompleteCall(
 684         Result: HRESULT,
 685     ) -> HRESULT,
 686     fn GetCallContext(
 687         riid: REFIID,
 688         pInterface: *mut *mut c_void,
 689     ) -> HRESULT,
 690     fn GetState(
 691         pulStateFlags: *mut ULONG,
 692     ) -> HRESULT,
 693 }}
 694 RIDL!{#[uuid(0x1c733a30, 0x2a1c, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d)]
 695 interface ICallFactory(ICallFactoryVtbl): IUnknown(IUnknownVtbl) {
 696     fn CreateCall(
 697         riid: REFIID,
 698         pCtrlUnk: *mut IUnknown,
 699         riid2: REFIID,
 700         ppv: *mut *mut IUnknown,
 701     ) -> HRESULT,
 702 }}
 703 RIDL!{#[uuid(0x00000149, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 704 interface IRpcHelper(IRpcHelperVtbl): IUnknown(IUnknownVtbl) {
 705     fn GetDCOMProtocolVersion(
 706         pComVersion: *mut DWORD,
 707     ) -> HRESULT,
 708     fn GetIIDFromOBJREF(
 709         pObjRef: *mut c_void,
 710         piid: *mut *mut IID,
 711     ) -> HRESULT,
 712 }}
 713 RIDL!{#[uuid(0xeb0cb9e8, 0x7996, 0x11d2, 0x87, 0x2e, 0x00, 0x00, 0xf8, 0x08, 0x08, 0x59)]
 714 interface IReleaseMarshalBuffers(IReleaseMarshalBuffersVtbl): IUnknown(IUnknownVtbl) {
 715     fn ReleaseMarshalBuffer(
 716         pMsg: *mut RPCOLEMESSAGE,
 717         dwFlags: DWORD,
 718         pChnl: *mut IUnknown,
 719     ) -> HRESULT,
 720 }}
 721 RIDL!{#[uuid(0x0000002b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 722 interface IWaitMultiple(IWaitMultipleVtbl): IUnknown(IUnknownVtbl) {
 723     fn WaitMultiple(
 724         timeout: DWORD,
 725         pSync: *mut *mut ISynchronize,
 726     ) -> HRESULT,
 727     fn AddSynchronize(
 728         pSync: *mut ISynchronize,
 729     ) -> HRESULT,
 730 }}
 731 pub type LPADDRTRACKINGCONTROL = *mut IAddrTrackingControl;
 732 RIDL!{#[uuid(0x00000147, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 733 interface IAddrTrackingControl(IAddrTrackingControlVtbl): IUnknown(IUnknownVtbl) {
 734     fn EnableCOMDynamicAddrTracking() -> HRESULT,
 735     fn DisableCOMDynamicAddrTracking() -> HRESULT,
 736 }}
 737 pub type LPADDREXCLUSIONCONTROL = *mut IAddrExclusionControl;
 738 RIDL!{#[uuid(0x00000148, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 739 interface IAddrExclusionControl(IAddrExclusionControlVtbl): IUnknown(IUnknownVtbl) {
 740     fn GetCurrentAddrExclusionList(
 741         riid: REFIID,
 742         ppEnumerator: *mut *mut c_void,
 743     ) -> HRESULT,
 744     fn UpdateAddrExclusionList(
 745         pEnumerator: *mut IUnknown,
 746     ) -> HRESULT,
 747 }}
 748 RIDL!{#[uuid(0xdb2f3aca, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 749 interface IPipeByte(IPipeByteVtbl): IUnknown(IUnknownVtbl) {
 750     fn Pull(
 751         buf: *mut BYTE,
 752         cRequest: ULONG,
 753         pcReturned: *mut ULONG,
 754     ) -> HRESULT,
 755     fn Push(
 756         buf: *mut BYTE,
 757         cSent: ULONG,
 758     ) -> HRESULT,
 759 }}
 760 RIDL!{#[uuid(0xdb2f3acb, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 761 interface AsyncIPipeByte(AsyncIPipeByteVtbl): IUnknown(IUnknownVtbl) {
 762     fn Begin_Pull(
 763         cRequest: ULONG,
 764     ) -> HRESULT,
 765     fn Finish_Pull(
 766         buf: *mut BYTE,
 767         pcReturned: *mut ULONG,
 768     ) -> HRESULT,
 769     fn Begin_Push(
 770         buf: *mut BYTE,
 771         cSent: ULONG,
 772     ) -> HRESULT,
 773     fn Finish_Push() -> HRESULT,
 774 }}
 775 RIDL!{#[uuid(0xdb2f3acc, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 776 interface IPipeLong(IPipeLongVtbl): IUnknown(IUnknownVtbl) {
 777     fn Pull(
 778         buf: *mut LONG,
 779         cRequest: ULONG,
 780         pcReturned: *mut ULONG,
 781     ) -> HRESULT,
 782     fn Push(
 783         buf: *mut LONG,
 784         cSent: ULONG,
 785     ) -> HRESULT,
 786 }}
 787 RIDL!{#[uuid(0xdb2f3acd, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 788 interface AsyncIPipeLong(AsyncIPipeLongVtbl): IUnknown(IUnknownVtbl) {
 789     fn Begin_Pull(
 790         cRequest: ULONG,
 791     ) -> HRESULT,
 792     fn Finish_Pull(
 793         buf: *mut LONG,
 794         pcReturned: *mut ULONG,
 795     ) -> HRESULT,
 796     fn Begin_Push(
 797         buf: *mut LONG,
 798         cSent: ULONG,
 799     ) -> HRESULT,
 800     fn Finish_Push() -> HRESULT,
 801 }}
 802 RIDL!{#[uuid(0xdb2f3ace, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 803 interface IPipeDouble(IPipeDoubleVtbl): IUnknown(IUnknownVtbl) {
 804     fn Pull(
 805         buf: *mut DOUBLE,
 806         cRequest: ULONG,
 807         pcReturned: *mut ULONG,
 808     ) -> HRESULT,
 809     fn Push(
 810         buf: *mut DOUBLE,
 811         cSent: ULONG,
 812     ) -> HRESULT,
 813 }}
 814 RIDL!{#[uuid(0xdb2f3acf, 0x2f86, 0x11d1, 0x8e, 0x04, 0x00, 0xc0, 0x4f, 0xb9, 0x98, 0x9a)]
 815 interface AsyncIPipeDouble(AsyncIPipeDoubleVtbl): IUnknown(IUnknownVtbl) {
 816     fn Begin_Pull(
 817         cRequest: ULONG,
 818     ) -> HRESULT,
 819     fn Finish_Pull(
 820         buf: *mut DOUBLE,
 821         pcReturned: *mut ULONG,
 822     ) -> HRESULT,
 823     fn Begin_Push(
 824         buf: *mut DOUBLE,
 825         cSent: ULONG,
 826     ) -> HRESULT,
 827     fn Finish_Push() -> HRESULT,
 828 }}
 829 pub type CPFLAGS = DWORD;
 830 STRUCT!{struct ContextProperty {
 831     policyId: GUID,
 832     flags: CPFLAGS,
 833     pUnk: *mut IUnknown,
 834 }}
 835 pub type LPENUMCONTEXTPROPS = *mut IEnumContextProps;
 836 RIDL!{#[uuid(0x000001c1, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 837 interface IEnumContextProps(IEnumContextPropsVtbl): IUnknown(IUnknownVtbl) {
 838     fn Next(
 839         celt: ULONG,
 840         pContextProperties: *mut ContextProperty,
 841         pceltFetched: *mut ULONG,
 842     ) -> HRESULT,
 843     fn Skip(
 844         celt: ULONG,
 845     ) -> HRESULT,
 846     fn Reset() -> HRESULT,
 847     fn Clone(
 848         ppEnumContextProps: *mut *mut IEnumContextProps,
 849     ) -> HRESULT,
 850     fn Count(
 851         pcelt: *mut ULONG,
 852     ) -> HRESULT,
 853 }}
 854 RIDL!{#[uuid(0x000001c0, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 855 interface IContext(IContextVtbl): IUnknown(IUnknownVtbl) {
 856     fn SetProperty(
 857         rpolicyId: REFGUID,
 858         flags: CPFLAGS,
 859         pUnk: *mut IUnknown,
 860     ) -> HRESULT,
 861     fn RemoveProperty(
 862         rPolicyId: REFGUID,
 863     ) -> HRESULT,
 864     fn GetProperty(
 865         policyId: REFGUID,
 866         pFlags: *mut CPFLAGS,
 867         ppUnk: *mut *mut IUnknown,
 868     ) -> HRESULT,
 869     fn EnumContextProps(
 870         ppEnumContextProps: *mut *mut IEnumContextProps,
 871     ) -> HRESULT,
 872 }}
 873 RIDL!{#[uuid(0x000001c6, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 874 interface IObjContext(IObjContextVtbl): IContext(IContextVtbl) {
 875     fn Reserved1() -> (),
 876     fn Reserved2() -> (),
 877     fn Reserved3() -> (),
 878     fn Reserved4() -> (),
 879     fn Reserved5() -> (),
 880     fn Reserved6() -> (),
 881     fn Reserved7() -> (),
 882 }}
 883 ENUM!{enum APTTYPEQUALIFIER {
 884     APTTYPEQUALIFIER_NONE = 0,
 885     APTTYPEQUALIFIER_IMPLICIT_MTA = 1,
 886     APTTYPEQUALIFIER_NA_ON_MTA = 2,
 887     APTTYPEQUALIFIER_NA_ON_STA = 3,
 888     APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA = 4,
 889     APTTYPEQUALIFIER_NA_ON_MAINSTA = 5,
 890     APTTYPEQUALIFIER_APPLICATION_STA= 6,
 891 }}
 892 ENUM!{enum APTTYPE {
 893     APTTYPE_CURRENT = -1i32 as u32,
 894     APTTYPE_STA = 0,
 895     APTTYPE_MTA = 1,
 896     APTTYPE_NA = 2,
 897     APTTYPE_MAINSTA = 3,
 898 }}
 899 ENUM!{enum THDTYPE {
 900     THDTYPE_BLOCKMESSAGES = 0,
 901     THDTYPE_PROCESSMESSAGES = 1,
 902 }}
 903 pub type APARTMENTID = DWORD;
 904 RIDL!{#[uuid(0x000001ce, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 905 interface IComThreadingInfo(IComThreadingInfoVtbl): IUnknown(IUnknownVtbl) {
 906     fn GetCurrentApartmentType(
 907         pAptType: *mut APTTYPE,
 908     ) -> HRESULT,
 909     fn GetCurrentThreadType(
 910         pThreadType: *mut THDTYPE,
 911     ) -> HRESULT,
 912     fn GetCurrentLogicalThreadId(
 913         pguidLogicalThreadId: *mut GUID,
 914     ) -> HRESULT,
 915     fn SetCurrentLogicalThreadId(
 916         rguid: REFGUID,
 917     ) -> HRESULT,
 918 }}
 919 RIDL!{#[uuid(0x72380d55, 0x8d2b, 0x43a3, 0x85, 0x13, 0x2b, 0x6e, 0xf3, 0x14, 0x34, 0xe9)]
 920 interface IProcessInitControl(IProcessInitControlVtbl): IUnknown(IUnknownVtbl) {
 921     fn ResetInitializerTimeout(
 922         dwSecondsRemaining: DWORD,
 923     ) -> HRESULT,
 924 }}
 925 RIDL!{#[uuid(0x00000040, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 926 interface IFastRundown(IFastRundownVtbl): IUnknown(IUnknownVtbl) {}}
 927 ENUM!{enum CO_MARSHALING_CONTEXT_ATTRIBUTES {
 928     CO_MARSHALING_SOURCE_IS_APP_CONTAINER = 0,
 929     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_1 = 0x80000000,
 930     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_2 = 0x80000001,
 931     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_3 = 0x80000002,
 932     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_4 = 0x80000003,
 933     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_5 = 0x80000004,
 934     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_6 = 0x80000005,
 935     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_7 = 0x80000006,
 936     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_8 = 0x80000007,
 937     CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_9 = 0x80000008,
 938 }}
 939 RIDL!{#[uuid(0xd8f2f5e6, 0x6102, 0x4863, 0x9f, 0x26, 0x38, 0x9a, 0x46, 0x76, 0xef, 0xde)]
 940 interface IMarshalingStream(IMarshalingStreamVtbl): IStream(IStreamVtbl) {
 941     fn GetMarshalingContextAttribute(
 942         attribute: CO_MARSHALING_CONTEXT_ATTRIBUTES,
 943         pAttributeValue: *mut ULONG_PTR,
 944     ) -> HRESULT,
 945 }}
 946 RIDL!{#[uuid(0xc03f6a43, 0x65a4, 0x9818, 0x98, 0x7e, 0xe0, 0xb8, 0x10, 0xd2, 0xa6, 0xf2)]
 947 interface IAgileReference(IAgileReferenceVtbl): IUnknown(IUnknownVtbl) {
 948     fn Resolve(
 949         riid: REFIID,
 950         ppvObjectReference: *mut *mut c_void,
 951     ) -> HRESULT,
 952 }}