nulib.system.win32.objidl source code

1 /**
2     Windows API header module
3 
4     Translated from MinGW Windows headers
5 
6     License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7 */
8 module nulib.system.win32.objidl;
9 import nulib.system.win32.windef;
10 import nulib.system.win32.basetyps;
11 import nulib.system.win32.oleidl;
12 import nulib.system.win32.wtypes;
13 import nulib.system.win32.winbase; // for FILETIME
14 import nulib.system.win32.rpcdce;
15 
16 
17 
18 enum STGM_DIRECT           = 0;
19 enum STGM_TRANSACTED       = 0x10000L;
20 enum STGM_SIMPLE           = 0x8000000L;
21 enum STGM_READ             = 0;
22 enum STGM_WRITE            = 1;
23 enum STGM_READWRITE        = 2;
24 enum STGM_SHARE_DENY_NONE  = 0x40;
25 enum STGM_SHARE_DENY_READ  = 0x30;
26 enum STGM_SHARE_DENY_WRITE = 0x20;
27 enum STGM_SHARE_EXCLUSIVE  = 0x10;
28 enum STGM_PRIORITY         = 0x40000L;
29 enum STGM_DELETEONRELEASE  = 0x4000000;
30 enum STGM_NOSCRATCH        = 0x100000;
31 enum STGM_CREATE           = 0x1000;
32 enum STGM_CONVERT          = 0x20000;
33 enum STGM_NOSNAPSHOT       = 0x200000;
34 enum STGM_FAILIFTHERE      = 0;
35 
36 enum ASYNC_MODE_COMPATIBILITY = 1;
37 enum ASYNC_MODE_DEFAULT       = 0;
38 
39 enum STGTY_REPEAT = 256;
40 enum STG_TOEND = 0xFFFFFFFF;
41 enum STG_LAYOUT_SEQUENTIAL  = 0;
42 enum STG_LAYOUT_INTERLEAVED = 1;
43 
44 enum COM_RIGHTS_EXECUTE            = 1;
45 enum COM_RIGHTS_SAFE_FOR_SCRIPTING = 2;
46 
47 enum STGOPTIONS_VERSION = 2;
48 
49 enum STGFMT {
50     STGFMT_STORAGE = 0,
51     STGFMT_FILE = 3,
52     STGFMT_ANY = 4,
53     STGFMT_DOCFILE = 5
54 }
55 
56 struct STGOPTIONS {
57     USHORT usVersion;
58     USHORT reserved;
59     ULONG ulSectorSize;
60     const(WCHAR)* pwcsTemplateFile;
61 }
62 
63 enum REGCLS {
64     REGCLS_SINGLEUSE = 0,
65     REGCLS_MULTIPLEUSE = 1,
66     REGCLS_MULTI_SEPARATE = 2
67 }
68 
69 struct STATSTG {
70     LPOLESTR pwcsName;
71     DWORD type;
72     ULARGE_INTEGER cbSize;
73     FILETIME mtime;
74     FILETIME ctime;
75     FILETIME atime;
76     DWORD grfMode;
77     DWORD grfLocksSupported;
78     CLSID clsid;
79     DWORD grfStateBits;
80     DWORD reserved;
81 }
82 
83 enum STGTY {
84     STGTY_STORAGE = 1,
85     STGTY_STREAM,
86     STGTY_LOCKBYTES,
87     STGTY_PROPERTY
88 }
89 
90 enum STREAM_SEEK {
91     STREAM_SEEK_SET,
92     STREAM_SEEK_CUR,
93     STREAM_SEEK_END
94 }
95 
96 struct INTERFACEINFO {
97     LPUNKNOWN pUnk;
98     IID iid;
99     WORD wMethod;
100 }
101 
102 alias LPINTERFACEINFO = INTERFACEINFO*;
103 
104 enum CALLTYPE {
105     CALLTYPE_TOPLEVEL = 1,
106     CALLTYPE_NESTED,
107     CALLTYPE_ASYNC,
108     CALLTYPE_TOPLEVEL_CALLPENDING,
109     CALLTYPE_ASYNC_CALLPENDING
110 }
111 
112 enum PENDINGTYPE {
113     PENDINGTYPE_TOPLEVEL = 1,
114     PENDINGTYPE_NESTED
115 }
116 
117 enum PENDINGMSG {
118     PENDINGMSG_CANCELCALL = 0,
119     PENDINGMSG_WAITNOPROCESS,
120     PENDINGMSG_WAITDEFPROCESS
121 }
122 
123 alias SNB = OLECHAR**;
124 
125 enum DATADIR {
126     DATADIR_GET = 1,
127     DATADIR_SET
128 }
129 
130 alias CLIPFORMAT = WORD;
131 alias LPCLIPFORMAT = CLIPFORMAT*;
132 
133 struct DVTARGETDEVICE {
134     DWORD tdSize;
135     WORD tdDriverNameOffset;
136     WORD tdDeviceNameOffset;
137     WORD tdPortNameOffset;
138     WORD tdExtDevmodeOffset;
139     BYTE[1] tdData;
140 }
141 
142 struct FORMATETC {
143     CLIPFORMAT cfFormat;
144     DVTARGETDEVICE* ptd;
145     DWORD dwAspect;
146     LONG lindex;
147     DWORD tymed;
148 }
149 
150 alias LPFORMATETC = FORMATETC*;
151 
152 struct RemSTGMEDIUM {
153     DWORD tymed;
154     DWORD dwHandleType;
155     ULONG pData;
156     uint pUnkForRelease;
157     uint cbData;
158     BYTE[1] data;
159 }
160 
161 struct HLITEM {
162     ULONG uHLID;
163     LPWSTR pwzFriendlyName;
164 }
165 
166 struct STATDATA {
167     FORMATETC formatetc;
168     DWORD grfAdvf;
169     IAdviseSink pAdvSink;
170     DWORD dwConnection;
171 }
172 
173 struct STATPROPSETSTG {
174     FMTID fmtid;
175     CLSID clsid;
176     DWORD grfFlags;
177     FILETIME mtime;
178     FILETIME ctime;
179     FILETIME atime;
180 }
181 
182 enum EXTCONN {
183     EXTCONN_STRONG = 1,
184     EXTCONN_WEAK = 2,
185     EXTCONN_CALLABLE = 4
186 }
187 
188 struct MULTI_QI {
189     const(IID)* pIID;
190     IUnknown pItf;
191     HRESULT hr;
192 }
193 
194 struct AUTH_IDENTITY {
195     USHORT* User;
196     ULONG UserLength;
197     USHORT* Domain;
198     ULONG DomainLength;
199     USHORT* Password;
200     ULONG PasswordLength;
201     ULONG Flags;
202 }
203 
204 struct COAUTHINFO {
205     DWORD dwAuthnSvc;
206     DWORD dwAuthzSvc;
207     LPWSTR pwszServerPrincName;
208     DWORD dwAuthnLevel;
209     DWORD dwImpersonationLevel;
210     AUTH_IDENTITY* pAuthIdentityData;
211     DWORD dwCapabilities;
212 }
213 
214 struct COSERVERINFO {
215     DWORD dwReserved1;
216     LPWSTR pwszName;
217     COAUTHINFO* pAuthInfo;
218     DWORD dwReserved2;
219 }
220 
221 struct BIND_OPTS {
222     DWORD cbStruct;
223     DWORD grfFlags;
224     DWORD grfMode;
225     DWORD dwTickCountDeadline;
226 }
227 
228 alias LPBIND_OPTS = BIND_OPTS*;
229 
230 struct BIND_OPTS2 {
231     DWORD cbStruct;
232     DWORD grfFlags;
233     DWORD grfMode;
234     DWORD dwTickCountDeadline;
235     DWORD dwTrackFlags;
236     DWORD dwClassContext;
237     LCID locale;
238     COSERVERINFO* pServerInfo;
239 }
240 
241 alias LPBIND_OPTS2 = BIND_OPTS2*;
242 
243 enum BIND_FLAGS {
244     BIND_MAYBOTHERUSER = 1,
245     BIND_JUSTTESTEXISTENCE
246 }
247 
248 struct STGMEDIUM {
249     DWORD tymed;
250     union {
251         HBITMAP hBitmap;
252         PVOID hMetaFilePict;
253         HENHMETAFILE hEnhMetaFile;
254         HGLOBAL hGlobal;
255         LPWSTR lpszFileName;
256         LPSTREAM pstm;
257         LPSTORAGE pstg;
258     }
259 
260     LPUNKNOWN pUnkForRelease;
261 }
262 
263 alias LPSTGMEDIUM = STGMEDIUM*;
264 
265 enum LOCKTYPE {
266     LOCK_WRITE = 1,
267     LOCK_EXCLUSIVE = 2,
268     LOCK_ONLYONCE = 4
269 }
270 
271 alias RPCOLEDATAREP = uint;
272 
273 struct RPCOLEMESSAGE {
274     PVOID reserved1;
275     RPCOLEDATAREP dataRepresentation;
276     PVOID Buffer;
277     ULONG cbBuffer;
278     ULONG iMethod;
279     PVOID[5] reserved2;
280     ULONG rpcFlags;
281 }
282 
283 alias PRPCOLEMESSAGE = RPCOLEMESSAGE*;
284 
285 enum MKSYS {
286     MKSYS_NONE,
287     MKSYS_GENERICCOMPOSITE,
288     MKSYS_FILEMONIKER,
289     MKSYS_ANTIMONIKER,
290     MKSYS_ITEMMONIKER,
291     MKSYS_POINTERMONIKER
292 }
293 
294 enum MKREDUCE {
295     MKRREDUCE_ALL,
296     MKRREDUCE_ONE = 196608,
297     MKRREDUCE_TOUSER = 131072,
298     MKRREDUCE_THROUGHUSER = 65536
299 }
300 
301 struct RemSNB {
302     uint ulCntStr;
303     uint ulCntChar;
304     OLECHAR[1] rgString = 0;
305 }
306 
307 enum ADVF {
308     ADVF_NODATA = 1,
309     ADVF_PRIMEFIRST = 2,
310     ADVF_ONLYONCE = 4,
311     ADVFCACHE_NOHANDLER = 8,
312     ADVFCACHE_FORCEBUILTIN = 16,
313     ADVFCACHE_ONSAVE = 32,
314     ADVF_DATAONSTOP = 64
315 }
316 
317 enum TYMED {
318     TYMED_HGLOBAL = 1,
319     TYMED_FILE = 2,
320     TYMED_ISTREAM = 4,
321     TYMED_ISTORAGE = 8,
322     TYMED_GDI = 16,
323     TYMED_MFPICT = 32,
324     TYMED_ENHMF = 64,
325     TYMED_NULL = 0
326 }
327 
328 enum SERVERCALL {
329     SERVERCALL_ISHANDLED,
330     SERVERCALL_REJECTED,
331     SERVERCALL_RETRYLATER
332 }
333 
334 struct CAUB {
335     ULONG cElems;
336     ubyte* pElems;
337 }
338 
339 struct CAI {
340     ULONG cElems;
341     short* pElems;
342 }
343 
344 struct CAUI {
345     ULONG cElems;
346     USHORT* pElems;
347 }
348 
349 struct CAL {
350     ULONG cElems;
351     int* pElems;
352 }
353 
354 struct CAUL {
355     ULONG cElems;
356     ULONG* pElems;
357 }
358 
359 struct CAFLT {
360     ULONG cElems;
361     float* pElems;
362 }
363 
364 struct CADBL {
365     ULONG cElems;
366     double* pElems;
367 }
368 
369 struct CACY {
370     ULONG cElems;
371     CY* pElems;
372 }
373 
374 struct CADATE {
375     ULONG cElems;
376     DATE* pElems;
377 }
378 
379 struct CABSTR {
380     ULONG cElems;
381     BSTR* pElems;
382 }
383 
384 struct CABSTRBLOB {
385     ULONG cElems;
386     BSTRBLOB* pElems;
387 }
388 
389 struct CABOOL {
390     ULONG cElems;
391     VARIANT_BOOL* pElems;
392 }
393 
394 struct CASCODE {
395     ULONG cElems;
396     SCODE* pElems;
397 }
398 
399 struct CAH {
400     ULONG cElems;
401     LARGE_INTEGER* pElems;
402 }
403 
404 struct CAUH {
405     ULONG cElems;
406     ULARGE_INTEGER* pElems;
407 }
408 
409 struct CALPSTR {
410     ULONG cElems;
411     LPSTR* pElems;
412 }
413 
414 struct CALPWSTR {
415     ULONG cElems;
416     LPWSTR* pElems;
417 }
418 
419 struct CAFILETIME {
420     ULONG cElems;
421     FILETIME* pElems;
422 }
423 
424 struct CACLIPDATA {
425     ULONG cElems;
426     CLIPDATA* pElems;
427 }
428 
429 struct CACLSID {
430     ULONG cElems;
431     CLSID* pElems;
432 }
433 
434 alias LPPROPVARIANT = PROPVARIANT*;
435 
436 struct CAPROPVARIANT {
437     ULONG cElems;
438     LPPROPVARIANT pElems;
439 }
440 
441 struct PROPVARIANT {
442     VARTYPE vt;
443     WORD wReserved1;
444     WORD wReserved2;
445     WORD wReserved3;
446     union {
447         CHAR cVal = 0;
448         UCHAR bVal;
449         short iVal;
450         USHORT uiVal;
451         VARIANT_BOOL boolVal;
452         int lVal;
453         ULONG ulVal;
454         float fltVal;
455         SCODE scode;
456         LARGE_INTEGER hVal;
457         ULARGE_INTEGER uhVal;
458         double dblVal;
459         CY cyVal;
460         DATE date;
461         FILETIME filetime;
462         CLSID* puuid;
463         BLOB blob;
464         CLIPDATA* pclipdata;
465         LPSTREAM pStream;
466         LPSTORAGE pStorage;
467         BSTR bstrVal;
468         BSTRBLOB bstrblobVal;
469         LPSTR pszVal;
470         LPWSTR pwszVal;
471         CAUB caub;
472         CAI cai;
473         CAUI caui;
474         CABOOL cabool;
475         CAL cal;
476         CAUL caul;
477         CAFLT caflt;
478         CASCODE cascode;
479         CAH cah;
480         CAUH cauh;
481         CADBL cadbl;
482         CACY cacy;
483         CADATE cadate;
484         CAFILETIME cafiletime;
485         CACLSID cauuid;
486         CACLIPDATA caclipdata;
487         CABSTR cabstr;
488         CABSTRBLOB cabstrblob;
489         CALPSTR calpstr;
490         CALPWSTR calpwstr;
491         CAPROPVARIANT capropvar;
492     }
493 }
494 
495 struct PROPSPEC {
496     ULONG ulKind;
497     union {
498         PROPID propid;
499         LPOLESTR lpwstr;
500     }
501 }
502 
503 struct STATPROPSTG {
504     LPOLESTR lpwstrName;
505     PROPID propid;
506     VARTYPE vt;
507 }
508 
509 enum PROPSETFLAG {
510     PROPSETFLAG_DEFAULT,
511     PROPSETFLAG_NONSIMPLE,
512     PROPSETFLAG_ANSI,
513     PROPSETFLAG_UNBUFFERED = 4
514 }
515 
516 struct STORAGELAYOUT {
517     DWORD LayoutType;
518     OLECHAR* pwcsElementName;
519     LARGE_INTEGER cOffset;
520     LARGE_INTEGER cBytes;
521 }
522 
523 struct SOLE_AUTHENTICATION_SERVICE {
524     DWORD dwAuthnSvc;
525     DWORD dwAuthzSvc;
526     OLECHAR* pPrincipalName;
527     HRESULT hr;
528 }
529 
530 enum OLECHAR* COLE_DEFAULT_PRINCIPAL = cast(OLECHAR*)(-1);
531 
532 enum EOLE_AUTHENTICATION_CAPABILITIES {
533     EOAC_NONE = 0,
534     EOAC_MUTUAL_AUTH = 0x1,
535     EOAC_SECURE_REFS = 0x2,
536     EOAC_ACCESS_CONTROL = 0x4,
537     EOAC_APPID = 0x8,
538     EOAC_DYNAMIC = 0x10,
539     EOAC_STATIC_CLOAKING = 0x20,
540     EOAC_DYNAMIC_CLOAKING = 0x40,
541     EOAC_ANY_AUTHORITY = 0x80,
542     EOAC_MAKE_FULLSIC = 0x100,
543     EOAC_REQUIRE_FULLSIC = 0x200,
544     EOAC_AUTO_IMPERSONATE = 0x400,
545     EOAC_DEFAULT = 0x800,
546     EOAC_DISABLE_AAA = 0x1000,
547     EOAC_NO_CUSTOM_MARSHAL = 0x2000
548 }
549 
550 struct SOLE_AUTHENTICATION_INFO {
551     DWORD dwAuthnSvc;
552     DWORD dwAuthzSvc;
553     void* pAuthInfo;
554 }
555 
556 enum void* COLE_DEFAULT_AUTHINFO = cast(void*)(-1);
557 
558 struct SOLE_AUTHENTICATION_LIST {
559     DWORD cAuthInfo;
560     SOLE_AUTHENTICATION_INFO* aAuthInfo;
561 }
562 
563 alias LPENUMFORMATETC = IEnumFORMATETC;
564 @Guid!("00000103-0000-0000-C000-000000000046")
565 interface IEnumFORMATETC : IUnknown {
566     HRESULT Next(ULONG, FORMATETC*, ULONG*);
567     HRESULT Skip(ULONG);
568     HRESULT Reset();
569     HRESULT Clone(IEnumFORMATETC*);
570 }
571 
572 alias LPENUMHLITEM = IEnumHLITEM;
573 @Guid!("79eac9c6-baf9-11ce-8c82-00aa004ba90b")
574 interface IEnumHLITEM : IUnknown {
575     HRESULT Next(ULONG, HLITEM*, ULONG*);
576     HRESULT Skip(ULONG);
577     HRESULT Reset();
578     HRESULT Clone(IEnumHLITEM*);
579 }
580 
581 alias LPENUMSTATDATA = IEnumSTATDATA;
582 @Guid!("00000105-0000-0000-C000-000000000046")
583 interface IEnumSTATDATA : IUnknown {
584     HRESULT Next(ULONG, STATDATA*, ULONG*);
585     HRESULT Skip(ULONG);
586     HRESULT Reset();
587     HRESULT Clone(IEnumSTATDATA*);
588 }
589 
590 alias LPENUMSTATSTG = IEnumSTATSTG;
591 @Guid!("0000000d-0000-0000-C000-000000000046")
592 interface IEnumSTATSTG : IUnknown {
593     HRESULT Next(ULONG, STATSTG*, ULONG*);
594     HRESULT Skip(ULONG);
595     HRESULT Reset();
596     HRESULT Clone(IEnumSTATSTG*);
597 }
598 
599 alias LPENUMSTATPROPSETSTG = IEnumSTATPROPSETSTG;
600 @Guid!("0000013B-0000-0000-C000-000000000046")
601 interface IEnumSTATPROPSETSTG : IUnknown {
602     HRESULT Next(ULONG, STATPROPSETSTG*, ULONG*);
603     HRESULT Skip(ULONG);
604     HRESULT Reset();
605     HRESULT Clone(IEnumSTATPROPSETSTG*);
606 }
607 
608 alias LPENUMSTATPROPSTG = IEnumSTATPROPSTG;
609 @Guid!("00000139-0000-0000-C000-000000000046")
610 interface IEnumSTATPROPSTG : IUnknown {
611     HRESULT Next(ULONG, STATPROPSTG*, ULONG*);
612     HRESULT Skip(ULONG);
613     HRESULT Reset();
614     HRESULT Clone(IEnumSTATPROPSTG*);
615 }
616 
617 alias LPENUMSTRING = IEnumString;
618 @Guid!("00000101-0000-0000-C000-000000000046")
619 interface IEnumString : IUnknown {
620     HRESULT Next(ULONG, LPOLESTR*, ULONG*);
621     HRESULT Skip(ULONG);
622     HRESULT Reset();
623     HRESULT Clone(IEnumString*);
624 }
625 
626 alias LPENUMMONIKER = IEnumMoniker;
627 @Guid!("00000102-0000-0000-C000-000000000046")
628 interface IEnumMoniker : IUnknown {
629     HRESULT Next(ULONG, IMoniker*, ULONG*);
630     HRESULT Skip(ULONG);
631     HRESULT Reset();
632     HRESULT Clone(IEnumMoniker*);
633 }
634 
635 alias LPENUMUNKNOWN = IEnumUnknown;
636 @Guid!("00000100-0000-0000-C000-000000000046")
637 interface IEnumUnknown : IUnknown {
638     HRESULT Next(ULONG, IUnknown*, ULONG*);
639     HRESULT Skip(ULONG);
640     HRESULT Reset();
641     HRESULT Clone(IEnumUnknown*);
642 }
643 
644 alias LPSEQUENTIALSTREAM = ISequentialStream;
645 @Guid!("0c733a30-2a1c-11ce-ade5-00aa0044773d")
646 interface ISequentialStream : IUnknown {
647     HRESULT Read(void*, ULONG, ULONG*);
648     HRESULT Write(void*, ULONG, ULONG*);
649 }
650 
651 alias LPSTREAM = IStream;
652 @Guid!("0000000c-0000-0000-C000-000000000046")
653 interface IStream : ISequentialStream {
654     HRESULT Seek(LARGE_INTEGER, DWORD, ULARGE_INTEGER*);
655     HRESULT SetSize(ULARGE_INTEGER);
656     HRESULT CopyTo(IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*);
657     HRESULT Commit(DWORD);
658     HRESULT Revert();
659     HRESULT LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
660     HRESULT UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
661     HRESULT Stat(STATSTG*, DWORD);
662     HRESULT Clone(LPSTREAM*);
663 }
664 
665 alias LPMARSHAL = IMarshal;
666 @Guid!("00000003-0000-0000-C000-000000000046")
667 interface IMarshal : IUnknown {
668     HRESULT GetUnmarshalClass(REFIID, PVOID, DWORD, PVOID, DWORD, CLSID*);
669     HRESULT GetMarshalSizeMax(REFIID, PVOID, DWORD, PVOID, DWORD, ULONG*);
670     HRESULT MarshalInterface(IStream, REFIID, PVOID, DWORD, PVOID, DWORD);
671     HRESULT UnmarshalInterface(IStream, REFIID, void**);
672     HRESULT ReleaseMarshalData(IStream);
673     HRESULT DisconnectObject(DWORD);
674 }
675 
676 alias LPSTDMARSHALINFO = IStdMarshalInfo;
677 @Guid!("00000018-0000-0000-C000-000000000046")
678 interface IStdMarshalInfo : IUnknown {
679     HRESULT GetClassForHandler(DWORD, PVOID, CLSID*);
680 }
681 
682 alias LPMALLOC = IMalloc;
683 @Guid!("00000002-0000-0000-C000-000000000046")
684 interface IMalloc : IUnknown {
685     void* Alloc(SIZE_T);
686     void* Realloc(void*, SIZE_T);
687     void Free(void*);
688     SIZE_T GetSize(void*);
689     int DidAlloc(void*);
690     void HeapMinimize();
691 }
692 
693 alias LPMALLOCSPY = IMallocSpy;
694 @Guid!("0000001d-0000-0000-C000-000000000046")
695 interface IMallocSpy : IUnknown {
696     SIZE_T PreAlloc(SIZE_T);
697     void* PostAlloc(void*);
698     void* PreFree(void*, BOOL);
699     void PostFree(BOOL);
700     SIZE_T PreRealloc(void*, SIZE_T, void**, BOOL);
701     void* PostRealloc(void*, BOOL);
702     void* PreGetSize(void*, BOOL);
703     SIZE_T PostGetSize(SIZE_T, BOOL);
704     void* PreDidAlloc(void*, BOOL);
705     int PostDidAlloc(void*, BOOL, int);
706     void PreHeapMinimize();
707     void PostHeapMinimize();
708 }
709 
710 alias LPMESSAGEFILTER = IMessageFilter;
711 @Guid!("00000016-0000-0000-C000-000000000046")
712 interface IMessageFilter : IUnknown {
713     DWORD HandleInComingCall(DWORD, HTASK, DWORD, LPINTERFACEINFO);
714     DWORD RetryRejectedCall(HTASK, DWORD, DWORD);
715     DWORD MessagePending(HTASK, DWORD, DWORD);
716 }
717 
718 alias LPPERSIST = IPersist;
719 @Guid!("0000010c-0000-0000-C000-000000000046")
720 interface IPersist : IUnknown {
721     HRESULT GetClassID(CLSID*);
722 }
723 
724 alias LPPERSISTSTREAM = IPersistStream;
725 @Guid!("00000109-0000-0000-C000-000000000046")
726 interface IPersistStream : IPersist {
727     HRESULT IsDirty();
728     HRESULT Load(IStream);
729     HRESULT Save(IStream, BOOL);
730     HRESULT GetSizeMax(PULARGE_INTEGER);
731 }
732 
733 alias LPRUNNINGOBJECTTABLE = IRunningObjectTable;
734 @Guid!("00000010-0000-0000-C000-000000000046")
735 interface IRunningObjectTable : IUnknown {
736     HRESULT Register(DWORD, LPUNKNOWN, LPMONIKER, PDWORD);
737     HRESULT Revoke(DWORD);
738     HRESULT IsRunning(LPMONIKER);
739     HRESULT GetObject(LPMONIKER, LPUNKNOWN*);
740     HRESULT NoteChangeTime(DWORD, LPFILETIME);
741     HRESULT GetTimeOfLastChange(LPMONIKER, LPFILETIME);
742     HRESULT EnumRunning(IEnumMoniker*);
743 }
744 
745 alias LPBINDCTX = IBindCtx;
746 @Guid!("0000000e-0000-0000-C000-000000000046")
747 interface IBindCtx : IUnknown {
748     HRESULT RegisterObjectBound(LPUNKNOWN);
749     HRESULT RevokeObjectBound(LPUNKNOWN);
750     HRESULT ReleaseBoundObjects();
751     HRESULT SetBindOptions(LPBIND_OPTS);
752     HRESULT GetBindOptions(LPBIND_OPTS);
753     HRESULT GetRunningObjectTable(IRunningObjectTable*);
754     HRESULT RegisterObjectParam(LPOLESTR, IUnknown);
755     HRESULT GetObjectParam(LPOLESTR, IUnknown*);
756     HRESULT EnumObjectParam(IEnumString*);
757     HRESULT RevokeObjectParam(LPOLESTR);
758 }
759 
760 alias LPMONIKER = IMoniker;
761 @Guid!("0000000f-0000-0000-C000-000000000046")
762 interface IMoniker : IPersistStream {
763     HRESULT BindToObject(IBindCtx, IMoniker, REFIID, PVOID*);
764     HRESULT BindToStorage(IBindCtx, IMoniker, REFIID, PVOID*);
765     HRESULT Reduce(IBindCtx, DWORD, IMoniker*, IMoniker*);
766     HRESULT ComposeWith(IMoniker, BOOL, IMoniker*);
767     HRESULT Enum(BOOL, IEnumMoniker*);
768     HRESULT IsEqual(IMoniker);
769     HRESULT Hash(PDWORD);
770     HRESULT IsRunning(IBindCtx, IMoniker, IMoniker);
771     HRESULT GetTimeOfLastChange(IBindCtx, IMoniker, LPFILETIME);
772     HRESULT Inverse(IMoniker*);
773     HRESULT CommonPrefixWith(IMoniker, IMoniker*);
774     HRESULT RelativePathTo(IMoniker, IMoniker*);
775     HRESULT GetDisplayName(IBindCtx, IMoniker, LPOLESTR*);
776     HRESULT ParseDisplayName(IBindCtx, IMoniker, LPOLESTR, ULONG*, IMoniker*);
777     HRESULT IsSystemMoniker(PDWORD);
778 }
779 
780 alias LPPERSISTSTORAGE = IPersistStorage;
781 @Guid!("0000010a-0000-0000-C000-000000000046")
782 interface IPersistStorage : IPersist {
783     HRESULT IsDirty();
784     HRESULT InitNew(LPSTORAGE);
785     HRESULT Load(LPSTORAGE);
786     HRESULT Save(LPSTORAGE, BOOL);
787     HRESULT SaveCompleted(LPSTORAGE);
788     HRESULT HandsOffStorage();
789 }
790 
791 alias LPPERSISTFILE = IPersistFile;
792 @Guid!("0000010b-0000-0000-C000-000000000046")
793 interface IPersistFile : IPersist {
794     HRESULT IsDirty();
795     HRESULT Load(LPCOLESTR, DWORD);
796     HRESULT Save(LPCOLESTR, BOOL);
797     HRESULT SaveCompleted(LPCOLESTR);
798     HRESULT GetCurFile(LPOLESTR*);
799 }
800 
801 // Async UUID: 00000150-0000-0000-C000-000000000046
802 alias LPADVISESINK = IAdviseSink;
803 @Guid!("0000010f-0000-0000-C000-000000000046")
804 interface IAdviseSink : IUnknown {
805     HRESULT QueryInterface(REFIID, PVOID*);
806     ULONG AddRef();
807     ULONG Release();
808     void OnDataChange(FORMATETC*, STGMEDIUM*);
809     void OnViewChange(DWORD, LONG);
810     void OnRename(IMoniker);
811     void OnSave();
812     void OnClose();
813 }
814 
815 // Async UUID: 00000150-0000-0000-C000-000000000046
816 alias LPADVISESINK2 = IAdviseSink2;
817 @Guid!("00000151-0000-0000-C000-000000000046")
818 interface IAdviseSink2 : IAdviseSink {
819     void OnLinkSrcChange(IMoniker);
820 }
821 
822 alias LPDATAOBJECT = IDataObject;
823 @Guid!("0000010e-0000-0000-C000-000000000046")
824 interface IDataObject : IUnknown {
825     HRESULT GetData(FORMATETC*, STGMEDIUM*);
826     HRESULT GetDataHere(FORMATETC*, STGMEDIUM*);
827     HRESULT QueryGetData(FORMATETC*);
828     HRESULT GetCanonicalFormatEtc(FORMATETC*, FORMATETC*);
829     HRESULT SetData(FORMATETC*, STGMEDIUM*, BOOL);
830     HRESULT EnumFormatEtc(DWORD, IEnumFORMATETC*);
831     HRESULT DAdvise(FORMATETC*, DWORD, IAdviseSink, PDWORD);
832     HRESULT DUnadvise(DWORD);
833     HRESULT EnumDAdvise(IEnumSTATDATA*);
834 }
835 
836 alias LPDATAADVISEHOLDER = IDataAdviseHolder;
837 @Guid!("00000110-0000-0000-C000-000000000046")
838 interface IDataAdviseHolder : IUnknown {
839     HRESULT Advise(IDataObject, FORMATETC*, DWORD, IAdviseSink, PDWORD);
840     HRESULT Unadvise(DWORD);
841     HRESULT EnumAdvise(IEnumSTATDATA*);
842     HRESULT SendOnDataChange(IDataObject, DWORD, DWORD);
843 }
844 
845 alias LPSTORAGE = IStorage;
846 @Guid!("0000000b-0000-0000-C000-000000000046")
847 interface IStorage : IUnknown {
848     HRESULT CreateStream(LPCWSTR, DWORD, DWORD, DWORD, IStream);
849     HRESULT OpenStream(LPCWSTR, PVOID, DWORD, DWORD, IStream);
850     HRESULT CreateStorage(LPCWSTR, DWORD, DWORD, DWORD, IStorage);
851     HRESULT OpenStorage(LPCWSTR, IStorage, DWORD, SNB, DWORD, IStorage);
852     HRESULT CopyTo(DWORD, IID*, SNB, IStorage);
853     HRESULT MoveElementTo(LPCWSTR, IStorage, LPCWSTR, DWORD);
854     HRESULT Commit(DWORD);
855     HRESULT Revert();
856     HRESULT EnumElements(DWORD, PVOID, DWORD, IEnumSTATSTG);
857     HRESULT DestroyElement(LPCWSTR);
858     HRESULT RenameElement(LPCWSTR, LPCWSTR);
859     HRESULT SetElementTimes(LPCWSTR, FILETIME*, FILETIME*, FILETIME*);
860     HRESULT SetClass(REFCLSID);
861     HRESULT SetStateBits(DWORD, DWORD);
862     HRESULT Stat(STATSTG*, DWORD);
863 }
864 
865 // FIXME: GetClassID from IPersist not there - what to do about it?
866 alias LPROOTSTORAGE = IRootStorage;
867 @Guid!("00000012-0000-0000-C000-000000000046")
868 interface IRootStorage : IPersist {
869     HRESULT QueryInterface(REFIID, PVOID*);
870     ULONG AddRef();
871     ULONG Release();
872     HRESULT SwitchToFile(LPOLESTR);
873 }
874 
875 alias LPRPCCHANNELBUFFER = IRpcChannelBuffer;
876 @Guid!("D5F56B60-593B-101A-B569-08002B2DBF7A")
877 interface IRpcChannelBuffer : IUnknown {
878     HRESULT GetBuffer(RPCOLEMESSAGE*, REFIID);
879     HRESULT SendReceive(RPCOLEMESSAGE*, PULONG);
880     HRESULT FreeBuffer(RPCOLEMESSAGE*);
881     HRESULT GetDestCtx(PDWORD, PVOID*);
882     HRESULT IsConnected();
883 }
884 
885 alias LPRPCPROXYBUFFER = IRpcProxyBuffer;
886 @Guid!("D5F56A34-593B-101A-B569-08002B2DBF7A")
887 interface IRpcProxyBuffer : IUnknown {
888     HRESULT Connect(IRpcChannelBuffer);
889     void Disconnect();
890 }
891 
892 alias LPRPCSTUBBUFFER = IRpcStubBuffer;
893 @Guid!("D5F56AFC-593B-101A-B569-08002B2DBF7A")
894 interface IRpcStubBuffer : IUnknown {
895     HRESULT Connect(LPUNKNOWN);
896     void Disconnect();
897     HRESULT Invoke(RPCOLEMESSAGE*, LPRPCSTUBBUFFER);
898     LPRPCSTUBBUFFER IsIIDSupported(REFIID);
899     ULONG CountRefs();
900     HRESULT DebugServerQueryInterface(PVOID*);
901     HRESULT DebugServerRelease(PVOID);
902 }
903 
904 alias LPPSFACTORYBUFFER = IPSFactoryBuffer;
905 @Guid!("D5F569D0-593B-101A-B569-08002B2DBF7A")
906 interface IPSFactoryBuffer : IUnknown {
907     HRESULT CreateProxy(LPUNKNOWN, REFIID, LPRPCPROXYBUFFER*, PVOID*);
908     HRESULT CreateStub(REFIID, LPUNKNOWN, LPRPCSTUBBUFFER*);
909 }
910 
911 alias LPLOCKBYTES = ILockBytes;
912 @Guid!("0000000a-0000-0000-C000-000000000046")
913 interface ILockBytes : IUnknown {
914     HRESULT ReadAt(ULARGE_INTEGER, PVOID, ULONG, ULONG*);
915     HRESULT WriteAt(ULARGE_INTEGER, PCVOID, ULONG, ULONG*);
916     HRESULT Flush();
917     HRESULT SetSize(ULARGE_INTEGER);
918     HRESULT LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
919     HRESULT UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
920     HRESULT Stat(STATSTG*, DWORD);
921 }
922 
923 alias LPEXTERNALCONNECTION = IExternalConnection;
924 @Guid!("00000019-0000-0000-C000-000000000046")
925 interface IExternalConnection : IUnknown {
926     HRESULT AddConnection(DWORD, DWORD);
927     HRESULT ReleaseConnection(DWORD, DWORD, BOOL);
928 }
929 
930 alias LPRUNNABLEOBJECT = IRunnableObject;
931 @Guid!("00000126-0000-0000-C000-000000000046")
932 interface IRunnableObject : IUnknown {
933     HRESULT GetRunningClass(LPCLSID);
934     HRESULT Run(LPBINDCTX);
935     BOOL IsRunning();
936     HRESULT LockRunning(BOOL, BOOL);
937     HRESULT SetContainedObject(BOOL);
938 }
939 
940 alias LPROTDATA = IROTData;
941 @Guid!("f29f6bc0-5021-11ce-aa15-00006901293f")
942 interface IROTData : IUnknown {
943     HRESULT GetComparisonData(PVOID, ULONG, PULONG);
944 }
945 
946 alias LPCHANNELHOOK = IChannelHook;
947 @Guid!("1008c4a0-7613-11cf-9af1-0020af6e72f4")
948 interface IChannelHook : IUnknown {
949     void ClientGetSize(REFGUID, REFIID, PULONG);
950     void ClientFillBuffer(REFGUID, REFIID, PULONG, PVOID);
951     void ClientNotify(REFGUID, REFIID, ULONG, PVOID, DWORD, HRESULT);
952     void ServerNotify(REFGUID, REFIID, ULONG, PVOID, DWORD);
953     void ServerGetSize(REFGUID, REFIID, HRESULT, PULONG);
954     void ServerFillBuffer(REFGUID, REFIID, PULONG, PVOID, HRESULT);
955 }
956 
957 alias LPPROPERTYSTORAGE = IPropertyStorage;
958 @Guid!("00000138-0000-0000-C000-000000000046")
959 interface IPropertyStorage : IUnknown {
960     HRESULT ReadMultiple(ULONG, PROPSPEC*, PROPVARIANT*);
961     HRESULT WriteMultiple(ULONG, PROPSPEC*, PROPVARIANT*, PROPID);
962     HRESULT DeleteMultiple(ULONG, PROPSPEC*);
963     HRESULT ReadPropertyNames(ULONG, PROPID*, LPWSTR*);
964     HRESULT WritePropertyNames(ULONG, PROPID*, LPWSTR*);
965     HRESULT DeletePropertyNames(ULONG, PROPID*);
966     HRESULT SetClass(REFCLSID);
967     HRESULT Commit(DWORD);
968     HRESULT Revert();
969     HRESULT Enum(IEnumSTATPROPSTG*);
970     HRESULT Stat(STATPROPSTG*);
971     HRESULT SetTimes(FILETIME*, FILETIME*, FILETIME*);
972 }
973 
974 alias LPPROPERTYSETSTORAGE = IPropertySetStorage;
975 @Guid!("0000013A-0000-0000-C000-000000000046")
976 interface IPropertySetStorage : IUnknown {
977     HRESULT Create(REFFMTID, CLSID*, DWORD, DWORD, LPPROPERTYSTORAGE*);
978     HRESULT Open(REFFMTID, DWORD, LPPROPERTYSTORAGE*);
979     HRESULT Delete(REFFMTID);
980     HRESULT Enum(IEnumSTATPROPSETSTG*);
981 }
982 
983 alias LPCLIENTSECURITY = IClientSecurity;
984 @Guid!("0000013D-0000-0000-C000-000000000046")
985 interface IClientSecurity : IUnknown {
986     HRESULT QueryBlanket(PVOID, PDWORD, PDWORD, OLECHAR**, PDWORD, PDWORD, RPC_AUTH_IDENTITY_HANDLE**, PDWORD*);
987     HRESULT SetBlanket(PVOID, DWORD, DWORD, LPWSTR, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE*, DWORD);
988     HRESULT CopyProxy(LPUNKNOWN, LPUNKNOWN*);
989 }
990 
991 alias LPSERVERSECURITY = IServerSecurity;
992 @Guid!("0000013E-0000-0000-C000-000000000046")
993 interface IServerSecurity : IUnknown {
994     HRESULT QueryBlanket(PDWORD, PDWORD, OLECHAR**, PDWORD, PDWORD, RPC_AUTHZ_HANDLE*, PDWORD*);
995     HRESULT ImpersonateClient();
996     HRESULT RevertToSelf();
997     HRESULT IsImpersonating();
998 }
999 
1000 alias LPCLASSACTIVATOR = IClassActivator;
1001 @Guid!("00000140-0000-0000-C000-000000000046")
1002 interface IClassActivator : IUnknown {
1003     HRESULT GetClassObject(REFCLSID, DWORD, LCID, REFIID, PVOID*);
1004 }
1005 
1006 alias LPFILLLOCKBYTES = IFillLockBytes;
1007 @Guid!("99caf010-415e-11cf-8814-00aa00b569f5")
1008 interface IFillLockBytes : IUnknown {
1009     HRESULT FillAppend(void*, ULONG, PULONG);
1010     HRESULT FillAt(ULARGE_INTEGER, void*, ULONG, PULONG);
1011     HRESULT SetFillSize(ULARGE_INTEGER);
1012     HRESULT Terminate(BOOL);
1013 }
1014 
1015 alias LPPROGRESSNOTIFY = IProgressNotify;
1016 @Guid!("a9d758a0-4617-11cf-95fc-00aa00680db4")
1017 interface IProgressNotify : IUnknown {
1018     HRESULT OnProgress(DWORD, DWORD, BOOL, BOOL);
1019 }
1020 
1021 alias LPLAYOUTSTORAGE = ILayoutStorage;
1022 @Guid!("0e6d4d90-6738-11cf-9608-00aa00680db4")
1023 interface ILayoutStorage : IUnknown {
1024     HRESULT LayoutScript(STORAGELAYOUT*, DWORD, DWORD);
1025     HRESULT BeginMonitor();
1026     HRESULT EndMonitor();
1027     HRESULT ReLayoutDocfile(OLECHAR*);
1028 }
1029 
1030 alias LPGLOBALINTERFACETABLE = IGlobalInterfaceTable;
1031 @Guid!("00000146-0000-0000-C000-000000000046")
1032 interface IGlobalInterfaceTable : IUnknown {
1033     HRESULT RegisterInterfaceInGlobal(IUnknown, REFIID, DWORD*);
1034     HRESULT RevokeInterfaceFromGlobal(DWORD);
1035     HRESULT GetInterfaceFromGlobal(DWORD, REFIID, void**);
1036 }
1037 
1038 extern(Windows) @nogc nothrow:
1039 
1040 HRESULT CoGetClassObject(REFCLSID, DWORD, COSERVERINFO*, REFIID, PVOID*);
1041 HRESULT CoRegisterClassObject(REFCLSID, LPUNKNOWN, DWORD, DWORD, PDWORD);
1042 HRESULT CoRevokeClassObject(DWORD);
1043 HRESULT CoGetMarshalSizeMax(ULONG*, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
1044 HRESULT CoMarshalInterface(LPSTREAM, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
1045 HRESULT CoUnmarshalInterface(LPSTREAM, REFIID, PVOID*);
1046 HRESULT CoMarshalHresult(LPSTREAM, HRESULT);
1047 HRESULT CoUnmarshalHresult(LPSTREAM, HRESULT*);
1048 HRESULT CoReleaseMarshalData(LPSTREAM);
1049 HRESULT CoDisconnectObject(LPUNKNOWN, DWORD);
1050 HRESULT CoLockObjectExternal(LPUNKNOWN, BOOL, BOOL);
1051 HRESULT CoGetStandardMarshal(REFIID, LPUNKNOWN, DWORD, PVOID, DWORD, LPMARSHAL*);
1052 HRESULT CoGetStdMarshalEx(LPUNKNOWN, DWORD, LPUNKNOWN*);
1053 BOOL CoIsHandlerConnected(LPUNKNOWN);
1054 BOOL CoHasStrongExternalConnections(LPUNKNOWN);
1055 HRESULT CoMarshalInterThreadInterfaceInStream(REFIID, LPUNKNOWN, LPSTREAM*);
1056 HRESULT CoGetInterfaceAndReleaseStream(LPSTREAM, REFIID, PVOID*);
1057 HRESULT CoCreateFreeThreadedMarshaler(LPUNKNOWN, LPUNKNOWN*);
1058 HINSTANCE CoLoadLibrary(LPOLESTR, BOOL);
1059 void CoFreeLibrary(HINSTANCE);
1060 void CoFreeAllLibraries();
1061 void CoFreeUnusedLibraries();
1062 HRESULT CoCreateInstance(REFCLSID, LPUNKNOWN, DWORD, REFIID, PVOID*);
1063 HRESULT CoCreateInstanceEx(REFCLSID, IUnknown, DWORD, COSERVERINFO*, DWORD, MULTI_QI*);
1064 HRESULT StringFromCLSID(REFCLSID, LPOLESTR*);
1065 HRESULT CLSIDFromString(LPOLESTR, LPCLSID);
1066 HRESULT StringFromIID(REFIID, LPOLESTR*);
1067 HRESULT IIDFromString(LPOLESTR, LPIID);
1068 BOOL CoIsOle1Class(REFCLSID);
1069 HRESULT ProgIDFromCLSID(REFCLSID, LPOLESTR*);
1070 HRESULT CLSIDFromProgID(LPCOLESTR, LPCLSID);
1071 int StringFromGUID2(REFGUID, LPOLESTR, int);
1072 HRESULT CoCreateGuid(GUID*);
1073 BOOL CoFileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD);
1074 BOOL CoDosDateTimeToFileTime(WORD, WORD, FILETIME*);
1075 HRESULT CoFileTimeNow(FILETIME*);
1076 HRESULT CoRegisterMessageFilter(LPMESSAGEFILTER, LPMESSAGEFILTER*);
1077 HRESULT CoGetTreatAsClass(REFCLSID, LPCLSID);
1078 HRESULT CoTreatAsClass(REFCLSID, REFCLSID);
1079 HRESULT DllGetClassObject(REFCLSID, REFIID, PVOID*);
1080 HRESULT DllCanUnloadNow();
1081 PVOID CoTaskMemAlloc(SIZE_T);
1082 PVOID CoTaskMemRealloc(PVOID, SIZE_T);
1083 void CoTaskMemFree(PVOID);
1084 HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*);
1085 HRESULT CreateDataCache(LPUNKNOWN, REFCLSID, REFIID, PVOID*);
1086 HRESULT StgCreateDocfile(const(OLECHAR)*, DWORD, DWORD, IStorage*);
1087 HRESULT StgCreateDocfileOnILockBytes(ILockBytes, DWORD, DWORD, IStorage*);
1088 HRESULT StgOpenStorage(const(OLECHAR)*, IStorage, DWORD, SNB, DWORD, IStorage*);
1089 HRESULT StgOpenStorageOnILockBytes(ILockBytes, IStorage, DWORD, SNB, DWORD, IStorage*);
1090 HRESULT StgIsStorageFile(const(OLECHAR)*);
1091 HRESULT StgIsStorageILockBytes(ILockBytes);
1092 HRESULT StgSetTimes(OLECHAR *, FILETIME *, FILETIME *, FILETIME *);
1093 HRESULT StgCreateStorageEx(const(WCHAR)*, DWORD, DWORD, DWORD, STGOPTIONS*, void*, REFIID, void**);
1094 HRESULT StgOpenStorageEx(const(WCHAR)*, DWORD, DWORD, DWORD, STGOPTIONS*, void*, REFIID, void**);
1095 HRESULT BindMoniker(LPMONIKER, DWORD, REFIID, PVOID*);
1096 HRESULT CoGetObject(LPCWSTR, BIND_OPTS*, REFIID, void**);
1097 HRESULT MkParseDisplayName(LPBINDCTX, LPCOLESTR, ULONG*, LPMONIKER*);
1098 HRESULT MonikerRelativePathTo(LPMONIKER, LPMONIKER, LPMONIKER*, BOOL);
1099 HRESULT MonikerCommonPrefixWith(LPMONIKER, LPMONIKER, LPMONIKER*);
1100 HRESULT CreateBindCtx(DWORD, LPBINDCTX*);
1101 HRESULT CreateGenericComposite(LPMONIKER, LPMONIKER, LPMONIKER*);
1102 HRESULT GetClassFile (LPCOLESTR, CLSID*);
1103 HRESULT CreateFileMoniker(LPCOLESTR, LPMONIKER*);
1104 HRESULT CreateItemMoniker(LPCOLESTR, LPCOLESTR, LPMONIKER*);
1105 HRESULT CreateAntiMoniker(LPMONIKER*);
1106 HRESULT CreatePointerMoniker(LPUNKNOWN, LPMONIKER*);
1107 HRESULT GetRunningObjectTable(DWORD, LPRUNNINGOBJECTTABLE*);
1108 HRESULT CoInitializeSecurity(PSECURITY_DESCRIPTOR, LONG, SOLE_AUTHENTICATION_SERVICE*, void*, DWORD, DWORD, void*, DWORD, void*);
1109 HRESULT CoGetCallContext(REFIID, void**);
1110 HRESULT CoQueryProxyBlanket(IUnknown*, DWORD*, DWORD*, OLECHAR**, DWORD*, DWORD*, RPC_AUTH_IDENTITY_HANDLE*, DWORD*);
1111 HRESULT CoSetProxyBlanket(IUnknown*, DWORD, DWORD, OLECHAR*, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE, DWORD);
1112 HRESULT CoCopyProxy(IUnknown*, IUnknown**);
1113 HRESULT CoQueryClientBlanket(DWORD*, DWORD*, OLECHAR**, DWORD*, DWORD*, RPC_AUTHZ_HANDLE*, DWORD*);
1114 HRESULT CoImpersonateClient();
1115 HRESULT CoRevertToSelf();
1116 HRESULT CoQueryAuthenticationServices(DWORD*, SOLE_AUTHENTICATION_SERVICE**);
1117 HRESULT CoSwitchCallContext(IUnknown*, IUnknown**);
1118 HRESULT CoGetInstanceFromFile(COSERVERINFO*, CLSID*, IUnknown*, DWORD, DWORD, OLECHAR*, DWORD, MULTI_QI*);
1119 HRESULT CoGetInstanceFromIStorage(COSERVERINFO*, CLSID*, IUnknown*, DWORD, IStorage*, DWORD, MULTI_QI*);
1120 ULONG CoAddRefServerProcess();
1121 ULONG CoReleaseServerProcess();
1122 HRESULT CoResumeClassObjects();
1123 HRESULT CoSuspendClassObjects();
1124 HRESULT CoGetPSClsid(REFIID, CLSID*);
1125 HRESULT CoRegisterPSClsid(REFIID, REFCLSID);