1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3 #[repr(C)]
4 pub struct BSTRBLOB {
5     pub cbSize: u32,
6     pub pData: *mut u8,
7 }
8 impl BSTRBLOB {}
9 impl ::std::default::Default for BSTRBLOB {
default() -> Self10     fn default() -> Self {
11         unsafe { ::std::mem::zeroed() }
12     }
13 }
14 impl ::std::fmt::Debug for BSTRBLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16         fmt.debug_struct("BSTRBLOB").field("cbSize", &self.cbSize).field("pData", &self.pData).finish()
17     }
18 }
19 impl ::std::cmp::PartialEq for BSTRBLOB {
eq(&self, other: &Self) -> bool20     fn eq(&self, other: &Self) -> bool {
21         self.cbSize == other.cbSize && self.pData == other.pData
22     }
23 }
24 impl ::std::cmp::Eq for BSTRBLOB {}
25 unsafe impl ::windows::runtime::Abi for BSTRBLOB {
26     type Abi = Self;
27     type DefaultType = Self;
28 }
29 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
30 #[repr(C)]
31 pub struct CABOOL {
32     pub cElems: u32,
33     pub pElems: *mut i16,
34 }
35 impl CABOOL {}
36 impl ::std::default::Default for CABOOL {
default() -> Self37     fn default() -> Self {
38         unsafe { ::std::mem::zeroed() }
39     }
40 }
41 impl ::std::fmt::Debug for CABOOL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result42     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
43         fmt.debug_struct("CABOOL").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
44     }
45 }
46 impl ::std::cmp::PartialEq for CABOOL {
eq(&self, other: &Self) -> bool47     fn eq(&self, other: &Self) -> bool {
48         self.cElems == other.cElems && self.pElems == other.pElems
49     }
50 }
51 impl ::std::cmp::Eq for CABOOL {}
52 unsafe impl ::windows::runtime::Abi for CABOOL {
53     type Abi = Self;
54     type DefaultType = Self;
55 }
56 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
57 #[repr(C)]
58 #[cfg(feature = "Win32_Foundation")]
59 pub struct CABSTR {
60     pub cElems: u32,
61     pub pElems: *mut super::super::super::Foundation::BSTR,
62 }
63 #[cfg(feature = "Win32_Foundation")]
64 impl CABSTR {}
65 #[cfg(feature = "Win32_Foundation")]
66 impl ::std::default::Default for CABSTR {
default() -> Self67     fn default() -> Self {
68         unsafe { ::std::mem::zeroed() }
69     }
70 }
71 #[cfg(feature = "Win32_Foundation")]
72 impl ::std::fmt::Debug for CABSTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result73     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
74         fmt.debug_struct("CABSTR").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
75     }
76 }
77 #[cfg(feature = "Win32_Foundation")]
78 impl ::std::cmp::PartialEq for CABSTR {
eq(&self, other: &Self) -> bool79     fn eq(&self, other: &Self) -> bool {
80         self.cElems == other.cElems && self.pElems == other.pElems
81     }
82 }
83 #[cfg(feature = "Win32_Foundation")]
84 impl ::std::cmp::Eq for CABSTR {}
85 #[cfg(feature = "Win32_Foundation")]
86 unsafe impl ::windows::runtime::Abi for CABSTR {
87     type Abi = Self;
88     type DefaultType = Self;
89 }
90 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
91 #[repr(C)]
92 pub struct CABSTRBLOB {
93     pub cElems: u32,
94     pub pElems: *mut BSTRBLOB,
95 }
96 impl CABSTRBLOB {}
97 impl ::std::default::Default for CABSTRBLOB {
default() -> Self98     fn default() -> Self {
99         unsafe { ::std::mem::zeroed() }
100     }
101 }
102 impl ::std::fmt::Debug for CABSTRBLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result103     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
104         fmt.debug_struct("CABSTRBLOB").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
105     }
106 }
107 impl ::std::cmp::PartialEq for CABSTRBLOB {
eq(&self, other: &Self) -> bool108     fn eq(&self, other: &Self) -> bool {
109         self.cElems == other.cElems && self.pElems == other.pElems
110     }
111 }
112 impl ::std::cmp::Eq for CABSTRBLOB {}
113 unsafe impl ::windows::runtime::Abi for CABSTRBLOB {
114     type Abi = Self;
115     type DefaultType = Self;
116 }
117 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
118 #[repr(C)]
119 #[cfg(feature = "Win32_Foundation")]
120 pub struct CAC {
121     pub cElems: u32,
122     pub pElems: super::super::super::Foundation::PSTR,
123 }
124 #[cfg(feature = "Win32_Foundation")]
125 impl CAC {}
126 #[cfg(feature = "Win32_Foundation")]
127 impl ::std::default::Default for CAC {
default() -> Self128     fn default() -> Self {
129         unsafe { ::std::mem::zeroed() }
130     }
131 }
132 #[cfg(feature = "Win32_Foundation")]
133 impl ::std::fmt::Debug for CAC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result134     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
135         fmt.debug_struct("CAC").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
136     }
137 }
138 #[cfg(feature = "Win32_Foundation")]
139 impl ::std::cmp::PartialEq for CAC {
eq(&self, other: &Self) -> bool140     fn eq(&self, other: &Self) -> bool {
141         self.cElems == other.cElems && self.pElems == other.pElems
142     }
143 }
144 #[cfg(feature = "Win32_Foundation")]
145 impl ::std::cmp::Eq for CAC {}
146 #[cfg(feature = "Win32_Foundation")]
147 unsafe impl ::windows::runtime::Abi for CAC {
148     type Abi = Self;
149     type DefaultType = Self;
150 }
151 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
152 #[repr(C)]
153 pub struct CACLIPDATA {
154     pub cElems: u32,
155     pub pElems: *mut CLIPDATA,
156 }
157 impl CACLIPDATA {}
158 impl ::std::default::Default for CACLIPDATA {
default() -> Self159     fn default() -> Self {
160         unsafe { ::std::mem::zeroed() }
161     }
162 }
163 impl ::std::fmt::Debug for CACLIPDATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result164     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
165         fmt.debug_struct("CACLIPDATA").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
166     }
167 }
168 impl ::std::cmp::PartialEq for CACLIPDATA {
eq(&self, other: &Self) -> bool169     fn eq(&self, other: &Self) -> bool {
170         self.cElems == other.cElems && self.pElems == other.pElems
171     }
172 }
173 impl ::std::cmp::Eq for CACLIPDATA {}
174 unsafe impl ::windows::runtime::Abi for CACLIPDATA {
175     type Abi = Self;
176     type DefaultType = Self;
177 }
178 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
179 #[repr(C)]
180 pub struct CACLSID {
181     pub cElems: u32,
182     pub pElems: *mut ::windows::runtime::GUID,
183 }
184 impl CACLSID {}
185 impl ::std::default::Default for CACLSID {
default() -> Self186     fn default() -> Self {
187         unsafe { ::std::mem::zeroed() }
188     }
189 }
190 impl ::std::fmt::Debug for CACLSID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result191     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
192         fmt.debug_struct("CACLSID").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
193     }
194 }
195 impl ::std::cmp::PartialEq for CACLSID {
eq(&self, other: &Self) -> bool196     fn eq(&self, other: &Self) -> bool {
197         self.cElems == other.cElems && self.pElems == other.pElems
198     }
199 }
200 impl ::std::cmp::Eq for CACLSID {}
201 unsafe impl ::windows::runtime::Abi for CACLSID {
202     type Abi = Self;
203     type DefaultType = Self;
204 }
205 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
206 #[repr(C)]
207 pub struct CACY {
208     pub cElems: u32,
209     pub pElems: *mut super::CY,
210 }
211 impl CACY {}
212 impl ::std::default::Default for CACY {
default() -> Self213     fn default() -> Self {
214         unsafe { ::std::mem::zeroed() }
215     }
216 }
217 impl ::std::fmt::Debug for CACY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result218     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
219         fmt.debug_struct("CACY").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
220     }
221 }
222 impl ::std::cmp::PartialEq for CACY {
eq(&self, other: &Self) -> bool223     fn eq(&self, other: &Self) -> bool {
224         self.cElems == other.cElems && self.pElems == other.pElems
225     }
226 }
227 impl ::std::cmp::Eq for CACY {}
228 unsafe impl ::windows::runtime::Abi for CACY {
229     type Abi = Self;
230     type DefaultType = Self;
231 }
232 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
233 #[repr(C)]
234 pub struct CADATE {
235     pub cElems: u32,
236     pub pElems: *mut f64,
237 }
238 impl CADATE {}
239 impl ::std::default::Default for CADATE {
default() -> Self240     fn default() -> Self {
241         unsafe { ::std::mem::zeroed() }
242     }
243 }
244 impl ::std::fmt::Debug for CADATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result245     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
246         fmt.debug_struct("CADATE").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
247     }
248 }
249 impl ::std::cmp::PartialEq for CADATE {
eq(&self, other: &Self) -> bool250     fn eq(&self, other: &Self) -> bool {
251         self.cElems == other.cElems && self.pElems == other.pElems
252     }
253 }
254 impl ::std::cmp::Eq for CADATE {}
255 unsafe impl ::windows::runtime::Abi for CADATE {
256     type Abi = Self;
257     type DefaultType = Self;
258 }
259 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
260 #[repr(C)]
261 pub struct CADBL {
262     pub cElems: u32,
263     pub pElems: *mut f64,
264 }
265 impl CADBL {}
266 impl ::std::default::Default for CADBL {
default() -> Self267     fn default() -> Self {
268         unsafe { ::std::mem::zeroed() }
269     }
270 }
271 impl ::std::fmt::Debug for CADBL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result272     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
273         fmt.debug_struct("CADBL").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
274     }
275 }
276 impl ::std::cmp::PartialEq for CADBL {
eq(&self, other: &Self) -> bool277     fn eq(&self, other: &Self) -> bool {
278         self.cElems == other.cElems && self.pElems == other.pElems
279     }
280 }
281 impl ::std::cmp::Eq for CADBL {}
282 unsafe impl ::windows::runtime::Abi for CADBL {
283     type Abi = Self;
284     type DefaultType = Self;
285 }
286 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
287 #[repr(C)]
288 #[cfg(feature = "Win32_Foundation")]
289 pub struct CAFILETIME {
290     pub cElems: u32,
291     pub pElems: *mut super::super::super::Foundation::FILETIME,
292 }
293 #[cfg(feature = "Win32_Foundation")]
294 impl CAFILETIME {}
295 #[cfg(feature = "Win32_Foundation")]
296 impl ::std::default::Default for CAFILETIME {
default() -> Self297     fn default() -> Self {
298         unsafe { ::std::mem::zeroed() }
299     }
300 }
301 #[cfg(feature = "Win32_Foundation")]
302 impl ::std::fmt::Debug for CAFILETIME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result303     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
304         fmt.debug_struct("CAFILETIME").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
305     }
306 }
307 #[cfg(feature = "Win32_Foundation")]
308 impl ::std::cmp::PartialEq for CAFILETIME {
eq(&self, other: &Self) -> bool309     fn eq(&self, other: &Self) -> bool {
310         self.cElems == other.cElems && self.pElems == other.pElems
311     }
312 }
313 #[cfg(feature = "Win32_Foundation")]
314 impl ::std::cmp::Eq for CAFILETIME {}
315 #[cfg(feature = "Win32_Foundation")]
316 unsafe impl ::windows::runtime::Abi for CAFILETIME {
317     type Abi = Self;
318     type DefaultType = Self;
319 }
320 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
321 #[repr(C)]
322 pub struct CAFLT {
323     pub cElems: u32,
324     pub pElems: *mut f32,
325 }
326 impl CAFLT {}
327 impl ::std::default::Default for CAFLT {
default() -> Self328     fn default() -> Self {
329         unsafe { ::std::mem::zeroed() }
330     }
331 }
332 impl ::std::fmt::Debug for CAFLT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result333     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
334         fmt.debug_struct("CAFLT").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
335     }
336 }
337 impl ::std::cmp::PartialEq for CAFLT {
eq(&self, other: &Self) -> bool338     fn eq(&self, other: &Self) -> bool {
339         self.cElems == other.cElems && self.pElems == other.pElems
340     }
341 }
342 impl ::std::cmp::Eq for CAFLT {}
343 unsafe impl ::windows::runtime::Abi for CAFLT {
344     type Abi = Self;
345     type DefaultType = Self;
346 }
347 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
348 #[repr(C)]
349 pub struct CAH {
350     pub cElems: u32,
351     pub pElems: *mut i64,
352 }
353 impl CAH {}
354 impl ::std::default::Default for CAH {
default() -> Self355     fn default() -> Self {
356         unsafe { ::std::mem::zeroed() }
357     }
358 }
359 impl ::std::fmt::Debug for CAH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result360     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
361         fmt.debug_struct("CAH").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
362     }
363 }
364 impl ::std::cmp::PartialEq for CAH {
eq(&self, other: &Self) -> bool365     fn eq(&self, other: &Self) -> bool {
366         self.cElems == other.cElems && self.pElems == other.pElems
367     }
368 }
369 impl ::std::cmp::Eq for CAH {}
370 unsafe impl ::windows::runtime::Abi for CAH {
371     type Abi = Self;
372     type DefaultType = Self;
373 }
374 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
375 #[repr(C)]
376 pub struct CAI {
377     pub cElems: u32,
378     pub pElems: *mut i16,
379 }
380 impl CAI {}
381 impl ::std::default::Default for CAI {
default() -> Self382     fn default() -> Self {
383         unsafe { ::std::mem::zeroed() }
384     }
385 }
386 impl ::std::fmt::Debug for CAI {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result387     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
388         fmt.debug_struct("CAI").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
389     }
390 }
391 impl ::std::cmp::PartialEq for CAI {
eq(&self, other: &Self) -> bool392     fn eq(&self, other: &Self) -> bool {
393         self.cElems == other.cElems && self.pElems == other.pElems
394     }
395 }
396 impl ::std::cmp::Eq for CAI {}
397 unsafe impl ::windows::runtime::Abi for CAI {
398     type Abi = Self;
399     type DefaultType = Self;
400 }
401 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
402 #[repr(C)]
403 pub struct CAL {
404     pub cElems: u32,
405     pub pElems: *mut i32,
406 }
407 impl CAL {}
408 impl ::std::default::Default for CAL {
default() -> Self409     fn default() -> Self {
410         unsafe { ::std::mem::zeroed() }
411     }
412 }
413 impl ::std::fmt::Debug for CAL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result414     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
415         fmt.debug_struct("CAL").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
416     }
417 }
418 impl ::std::cmp::PartialEq for CAL {
eq(&self, other: &Self) -> bool419     fn eq(&self, other: &Self) -> bool {
420         self.cElems == other.cElems && self.pElems == other.pElems
421     }
422 }
423 impl ::std::cmp::Eq for CAL {}
424 unsafe impl ::windows::runtime::Abi for CAL {
425     type Abi = Self;
426     type DefaultType = Self;
427 }
428 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
429 #[repr(C)]
430 #[cfg(feature = "Win32_Foundation")]
431 pub struct CALPSTR {
432     pub cElems: u32,
433     pub pElems: *mut super::super::super::Foundation::PSTR,
434 }
435 #[cfg(feature = "Win32_Foundation")]
436 impl CALPSTR {}
437 #[cfg(feature = "Win32_Foundation")]
438 impl ::std::default::Default for CALPSTR {
default() -> Self439     fn default() -> Self {
440         unsafe { ::std::mem::zeroed() }
441     }
442 }
443 #[cfg(feature = "Win32_Foundation")]
444 impl ::std::fmt::Debug for CALPSTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result445     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
446         fmt.debug_struct("CALPSTR").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
447     }
448 }
449 #[cfg(feature = "Win32_Foundation")]
450 impl ::std::cmp::PartialEq for CALPSTR {
eq(&self, other: &Self) -> bool451     fn eq(&self, other: &Self) -> bool {
452         self.cElems == other.cElems && self.pElems == other.pElems
453     }
454 }
455 #[cfg(feature = "Win32_Foundation")]
456 impl ::std::cmp::Eq for CALPSTR {}
457 #[cfg(feature = "Win32_Foundation")]
458 unsafe impl ::windows::runtime::Abi for CALPSTR {
459     type Abi = Self;
460     type DefaultType = Self;
461 }
462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
463 #[repr(C)]
464 #[cfg(feature = "Win32_Foundation")]
465 pub struct CALPWSTR {
466     pub cElems: u32,
467     pub pElems: *mut super::super::super::Foundation::PWSTR,
468 }
469 #[cfg(feature = "Win32_Foundation")]
470 impl CALPWSTR {}
471 #[cfg(feature = "Win32_Foundation")]
472 impl ::std::default::Default for CALPWSTR {
default() -> Self473     fn default() -> Self {
474         unsafe { ::std::mem::zeroed() }
475     }
476 }
477 #[cfg(feature = "Win32_Foundation")]
478 impl ::std::fmt::Debug for CALPWSTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result479     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
480         fmt.debug_struct("CALPWSTR").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
481     }
482 }
483 #[cfg(feature = "Win32_Foundation")]
484 impl ::std::cmp::PartialEq for CALPWSTR {
eq(&self, other: &Self) -> bool485     fn eq(&self, other: &Self) -> bool {
486         self.cElems == other.cElems && self.pElems == other.pElems
487     }
488 }
489 #[cfg(feature = "Win32_Foundation")]
490 impl ::std::cmp::Eq for CALPWSTR {}
491 #[cfg(feature = "Win32_Foundation")]
492 unsafe impl ::windows::runtime::Abi for CALPWSTR {
493     type Abi = Self;
494     type DefaultType = Self;
495 }
496 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
497 #[repr(C)]
498 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
499 pub struct CAPROPVARIANT {
500     pub cElems: u32,
501     pub pElems: *mut PROPVARIANT,
502 }
503 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
504 impl CAPROPVARIANT {}
505 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
506 impl ::std::default::Default for CAPROPVARIANT {
default() -> Self507     fn default() -> Self {
508         unsafe { ::std::mem::zeroed() }
509     }
510 }
511 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
512 impl ::std::fmt::Debug for CAPROPVARIANT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result513     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
514         fmt.debug_struct("CAPROPVARIANT").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
515     }
516 }
517 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
518 impl ::std::cmp::PartialEq for CAPROPVARIANT {
eq(&self, other: &Self) -> bool519     fn eq(&self, other: &Self) -> bool {
520         self.cElems == other.cElems && self.pElems == other.pElems
521     }
522 }
523 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
524 impl ::std::cmp::Eq for CAPROPVARIANT {}
525 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
526 unsafe impl ::windows::runtime::Abi for CAPROPVARIANT {
527     type Abi = Self;
528     type DefaultType = Self;
529 }
530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
531 #[repr(C)]
532 pub struct CASCODE {
533     pub cElems: u32,
534     pub pElems: *mut i32,
535 }
536 impl CASCODE {}
537 impl ::std::default::Default for CASCODE {
default() -> Self538     fn default() -> Self {
539         unsafe { ::std::mem::zeroed() }
540     }
541 }
542 impl ::std::fmt::Debug for CASCODE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
544         fmt.debug_struct("CASCODE").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
545     }
546 }
547 impl ::std::cmp::PartialEq for CASCODE {
eq(&self, other: &Self) -> bool548     fn eq(&self, other: &Self) -> bool {
549         self.cElems == other.cElems && self.pElems == other.pElems
550     }
551 }
552 impl ::std::cmp::Eq for CASCODE {}
553 unsafe impl ::windows::runtime::Abi for CASCODE {
554     type Abi = Self;
555     type DefaultType = Self;
556 }
557 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
558 #[repr(C)]
559 pub struct CAUB {
560     pub cElems: u32,
561     pub pElems: *mut u8,
562 }
563 impl CAUB {}
564 impl ::std::default::Default for CAUB {
default() -> Self565     fn default() -> Self {
566         unsafe { ::std::mem::zeroed() }
567     }
568 }
569 impl ::std::fmt::Debug for CAUB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result570     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
571         fmt.debug_struct("CAUB").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
572     }
573 }
574 impl ::std::cmp::PartialEq for CAUB {
eq(&self, other: &Self) -> bool575     fn eq(&self, other: &Self) -> bool {
576         self.cElems == other.cElems && self.pElems == other.pElems
577     }
578 }
579 impl ::std::cmp::Eq for CAUB {}
580 unsafe impl ::windows::runtime::Abi for CAUB {
581     type Abi = Self;
582     type DefaultType = Self;
583 }
584 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
585 #[repr(C)]
586 pub struct CAUH {
587     pub cElems: u32,
588     pub pElems: *mut u64,
589 }
590 impl CAUH {}
591 impl ::std::default::Default for CAUH {
default() -> Self592     fn default() -> Self {
593         unsafe { ::std::mem::zeroed() }
594     }
595 }
596 impl ::std::fmt::Debug for CAUH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result597     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
598         fmt.debug_struct("CAUH").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
599     }
600 }
601 impl ::std::cmp::PartialEq for CAUH {
eq(&self, other: &Self) -> bool602     fn eq(&self, other: &Self) -> bool {
603         self.cElems == other.cElems && self.pElems == other.pElems
604     }
605 }
606 impl ::std::cmp::Eq for CAUH {}
607 unsafe impl ::windows::runtime::Abi for CAUH {
608     type Abi = Self;
609     type DefaultType = Self;
610 }
611 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
612 #[repr(C)]
613 pub struct CAUI {
614     pub cElems: u32,
615     pub pElems: *mut u16,
616 }
617 impl CAUI {}
618 impl ::std::default::Default for CAUI {
default() -> Self619     fn default() -> Self {
620         unsafe { ::std::mem::zeroed() }
621     }
622 }
623 impl ::std::fmt::Debug for CAUI {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result624     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
625         fmt.debug_struct("CAUI").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
626     }
627 }
628 impl ::std::cmp::PartialEq for CAUI {
eq(&self, other: &Self) -> bool629     fn eq(&self, other: &Self) -> bool {
630         self.cElems == other.cElems && self.pElems == other.pElems
631     }
632 }
633 impl ::std::cmp::Eq for CAUI {}
634 unsafe impl ::windows::runtime::Abi for CAUI {
635     type Abi = Self;
636     type DefaultType = Self;
637 }
638 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
639 #[repr(C)]
640 pub struct CAUL {
641     pub cElems: u32,
642     pub pElems: *mut u32,
643 }
644 impl CAUL {}
645 impl ::std::default::Default for CAUL {
default() -> Self646     fn default() -> Self {
647         unsafe { ::std::mem::zeroed() }
648     }
649 }
650 impl ::std::fmt::Debug for CAUL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result651     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
652         fmt.debug_struct("CAUL").field("cElems", &self.cElems).field("pElems", &self.pElems).finish()
653     }
654 }
655 impl ::std::cmp::PartialEq for CAUL {
eq(&self, other: &Self) -> bool656     fn eq(&self, other: &Self) -> bool {
657         self.cElems == other.cElems && self.pElems == other.pElems
658     }
659 }
660 impl ::std::cmp::Eq for CAUL {}
661 unsafe impl ::windows::runtime::Abi for CAUL {
662     type Abi = Self;
663     type DefaultType = Self;
664 }
665 pub const CCH_MAX_PROPSTG_NAME: u32 = 31u32;
666 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
667 #[repr(C)]
668 pub struct CLIPDATA {
669     pub cbSize: u32,
670     pub ulClipFmt: i32,
671     pub pClipData: *mut u8,
672 }
673 impl CLIPDATA {}
674 impl ::std::default::Default for CLIPDATA {
default() -> Self675     fn default() -> Self {
676         unsafe { ::std::mem::zeroed() }
677     }
678 }
679 impl ::std::fmt::Debug for CLIPDATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result680     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
681         fmt.debug_struct("CLIPDATA").field("cbSize", &self.cbSize).field("ulClipFmt", &self.ulClipFmt).field("pClipData", &self.pClipData).finish()
682     }
683 }
684 impl ::std::cmp::PartialEq for CLIPDATA {
eq(&self, other: &Self) -> bool685     fn eq(&self, other: &Self) -> bool {
686         self.cbSize == other.cbSize && self.ulClipFmt == other.ulClipFmt && self.pClipData == other.pClipData
687     }
688 }
689 impl ::std::cmp::Eq for CLIPDATA {}
690 unsafe impl ::windows::runtime::Abi for CLIPDATA {
691     type Abi = Self;
692     type DefaultType = Self;
693 }
694 pub const CWCSTORAGENAME: u32 = 32u32;
695 #[cfg(feature = "Win32_Foundation")]
696 #[inline]
CoGetInstanceFromFile<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: Param2, dwclsctx: super::CLSCTX, grfmode: u32, pwszname: Param5, dwcount: u32, presults: *mut super::MULTI_QI) -> ::windows::runtime::Result<()>697 pub unsafe fn CoGetInstanceFromFile<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: Param2, dwclsctx: super::CLSCTX, grfmode: u32, pwszname: Param5, dwcount: u32, presults: *mut super::MULTI_QI) -> ::windows::runtime::Result<()> {
698     #[cfg(windows)]
699     {
700         #[link(name = "windows")]
701         extern "system" {
702             fn CoGetInstanceFromFile(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: ::windows::runtime::RawPtr, dwclsctx: super::CLSCTX, grfmode: u32, pwszname: super::super::super::Foundation::PWSTR, dwcount: u32, presults: *mut ::std::mem::ManuallyDrop<super::MULTI_QI>) -> ::windows::runtime::HRESULT;
703         }
704         CoGetInstanceFromFile(::std::mem::transmute(pserverinfo), ::std::mem::transmute(pclsid), punkouter.into_param().abi(), ::std::mem::transmute(dwclsctx), ::std::mem::transmute(grfmode), pwszname.into_param().abi(), ::std::mem::transmute(dwcount), ::std::mem::transmute(presults)).ok()
705     }
706     #[cfg(not(windows))]
707     unimplemented!("Unsupported target OS");
708 }
709 #[cfg(feature = "Win32_Foundation")]
710 #[inline]
CoGetInstanceFromIStorage<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param4: ::windows::runtime::IntoParam<'a, IStorage>>(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: Param2, dwclsctx: super::CLSCTX, pstg: Param4, dwcount: u32, presults: *mut super::MULTI_QI) -> ::windows::runtime::Result<()>711 pub unsafe fn CoGetInstanceFromIStorage<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param4: ::windows::runtime::IntoParam<'a, IStorage>>(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: Param2, dwclsctx: super::CLSCTX, pstg: Param4, dwcount: u32, presults: *mut super::MULTI_QI) -> ::windows::runtime::Result<()> {
712     #[cfg(windows)]
713     {
714         #[link(name = "windows")]
715         extern "system" {
716             fn CoGetInstanceFromIStorage(pserverinfo: *const super::COSERVERINFO, pclsid: *const ::windows::runtime::GUID, punkouter: ::windows::runtime::RawPtr, dwclsctx: super::CLSCTX, pstg: ::windows::runtime::RawPtr, dwcount: u32, presults: *mut ::std::mem::ManuallyDrop<super::MULTI_QI>) -> ::windows::runtime::HRESULT;
717         }
718         CoGetInstanceFromIStorage(::std::mem::transmute(pserverinfo), ::std::mem::transmute(pclsid), punkouter.into_param().abi(), ::std::mem::transmute(dwclsctx), pstg.into_param().abi(), ::std::mem::transmute(dwcount), ::std::mem::transmute(presults)).ok()
719     }
720     #[cfg(not(windows))]
721     unimplemented!("Unsupported target OS");
722 }
723 #[inline]
CoGetInterfaceAndReleaseStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>, T: ::windows::runtime::Interface>(pstm: Param0) -> ::windows::runtime::Result<T>724 pub unsafe fn CoGetInterfaceAndReleaseStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>, T: ::windows::runtime::Interface>(pstm: Param0) -> ::windows::runtime::Result<T> {
725     #[cfg(windows)]
726     {
727         #[link(name = "windows")]
728         extern "system" {
729             fn CoGetInterfaceAndReleaseStream(pstm: ::windows::runtime::RawPtr, iid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
730         }
731         let mut result__ = ::std::option::Option::None;
732         CoGetInterfaceAndReleaseStream(pstm.into_param().abi(), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
733     }
734     #[cfg(not(windows))]
735     unimplemented!("Unsupported target OS");
736 }
737 #[cfg(feature = "Win32_Foundation")]
738 #[inline]
CreateILockBytesOnHGlobal<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hglobal: isize, fdeleteonrelease: Param1) -> ::windows::runtime::Result<ILockBytes>739 pub unsafe fn CreateILockBytesOnHGlobal<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hglobal: isize, fdeleteonrelease: Param1) -> ::windows::runtime::Result<ILockBytes> {
740     #[cfg(windows)]
741     {
742         #[link(name = "windows")]
743         extern "system" {
744             fn CreateILockBytesOnHGlobal(hglobal: isize, fdeleteonrelease: super::super::super::Foundation::BOOL, pplkbyt: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
745         }
746         let mut result__: <ILockBytes as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
747         CreateILockBytesOnHGlobal(::std::mem::transmute(hglobal), fdeleteonrelease.into_param().abi(), &mut result__).from_abi::<ILockBytes>(result__)
748     }
749     #[cfg(not(windows))]
750     unimplemented!("Unsupported target OS");
751 }
752 #[cfg(feature = "Win32_Foundation")]
753 #[inline]
CreateStreamOnHGlobal<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hglobal: isize, fdeleteonrelease: Param1) -> ::windows::runtime::Result<super::IStream>754 pub unsafe fn CreateStreamOnHGlobal<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(hglobal: isize, fdeleteonrelease: Param1) -> ::windows::runtime::Result<super::IStream> {
755     #[cfg(windows)]
756     {
757         #[link(name = "windows")]
758         extern "system" {
759             fn CreateStreamOnHGlobal(hglobal: isize, fdeleteonrelease: super::super::super::Foundation::BOOL, ppstm: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
760         }
761         let mut result__: <super::IStream as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
762         CreateStreamOnHGlobal(::std::mem::transmute(hglobal), fdeleteonrelease.into_param().abi(), &mut result__).from_abi::<super::IStream>(result__)
763     }
764     #[cfg(not(windows))]
765     unimplemented!("Unsupported target OS");
766 }
767 #[cfg(feature = "Win32_Foundation")]
768 #[inline]
FmtIdToPropStgName(pfmtid: *const ::windows::runtime::GUID, oszname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()>769 pub unsafe fn FmtIdToPropStgName(pfmtid: *const ::windows::runtime::GUID, oszname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
770     #[cfg(windows)]
771     {
772         #[link(name = "windows")]
773         extern "system" {
774             fn FmtIdToPropStgName(pfmtid: *const ::windows::runtime::GUID, oszname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
775         }
776         FmtIdToPropStgName(::std::mem::transmute(pfmtid), ::std::mem::transmute(oszname)).ok()
777     }
778     #[cfg(not(windows))]
779     unimplemented!("Unsupported target OS");
780 }
781 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
782 #[inline]
FreePropVariantArray(cvariants: u32, rgvars: *mut PROPVARIANT) -> ::windows::runtime::Result<()>783 pub unsafe fn FreePropVariantArray(cvariants: u32, rgvars: *mut PROPVARIANT) -> ::windows::runtime::Result<()> {
784     #[cfg(windows)]
785     {
786         #[link(name = "windows")]
787         extern "system" {
788             fn FreePropVariantArray(cvariants: u32, rgvars: *mut ::std::mem::ManuallyDrop<PROPVARIANT>) -> ::windows::runtime::HRESULT;
789         }
790         FreePropVariantArray(::std::mem::transmute(cvariants), ::std::mem::transmute(rgvars)).ok()
791     }
792     #[cfg(not(windows))]
793     unimplemented!("Unsupported target OS");
794 }
795 #[inline]
GetConvertStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0) -> ::windows::runtime::Result<()>796 pub unsafe fn GetConvertStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0) -> ::windows::runtime::Result<()> {
797     #[cfg(windows)]
798     {
799         #[link(name = "windows")]
800         extern "system" {
801             fn GetConvertStg(pstg: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
802         }
803         GetConvertStg(pstg.into_param().abi()).ok()
804     }
805     #[cfg(not(windows))]
806     unimplemented!("Unsupported target OS");
807 }
808 #[inline]
GetHGlobalFromILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0) -> ::windows::runtime::Result<isize>809 pub unsafe fn GetHGlobalFromILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0) -> ::windows::runtime::Result<isize> {
810     #[cfg(windows)]
811     {
812         #[link(name = "windows")]
813         extern "system" {
814             fn GetHGlobalFromILockBytes(plkbyt: ::windows::runtime::RawPtr, phglobal: *mut isize) -> ::windows::runtime::HRESULT;
815         }
816         let mut result__: <isize as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
817         GetHGlobalFromILockBytes(plkbyt.into_param().abi(), &mut result__).from_abi::<isize>(result__)
818     }
819     #[cfg(not(windows))]
820     unimplemented!("Unsupported target OS");
821 }
822 #[inline]
GetHGlobalFromStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0) -> ::windows::runtime::Result<isize>823 pub unsafe fn GetHGlobalFromStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0) -> ::windows::runtime::Result<isize> {
824     #[cfg(windows)]
825     {
826         #[link(name = "windows")]
827         extern "system" {
828             fn GetHGlobalFromStream(pstm: ::windows::runtime::RawPtr, phglobal: *mut isize) -> ::windows::runtime::HRESULT;
829         }
830         let mut result__: <isize as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
831         GetHGlobalFromStream(pstm.into_param().abi(), &mut result__).from_abi::<isize>(result__)
832     }
833     #[cfg(not(windows))]
834     unimplemented!("Unsupported target OS");
835 }
836 #[repr(transparent)]
837 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
838 pub struct IDirectWriterLock(::windows::runtime::IUnknown);
839 impl IDirectWriterLock {
WaitForWriteAccess(&self, dwtimeout: u32) -> ::windows::runtime::Result<()>840     pub unsafe fn WaitForWriteAccess(&self, dwtimeout: u32) -> ::windows::runtime::Result<()> {
841         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwtimeout)).ok()
842     }
ReleaseWriteAccess(&self) -> ::windows::runtime::Result<()>843     pub unsafe fn ReleaseWriteAccess(&self) -> ::windows::runtime::Result<()> {
844         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self)).ok()
845     }
HaveWriteAccess(&self) -> ::windows::runtime::Result<()>846     pub unsafe fn HaveWriteAccess(&self) -> ::windows::runtime::Result<()> {
847         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
848     }
849 }
850 unsafe impl ::windows::runtime::Interface for IDirectWriterLock {
851     type Vtable = IDirectWriterLock_abi;
852     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(242044306, 26424, 4559, [150, 8, 0, 170, 0, 104, 13, 180]);
853 }
854 impl ::std::convert::From<IDirectWriterLock> for ::windows::runtime::IUnknown {
from(value: IDirectWriterLock) -> Self855     fn from(value: IDirectWriterLock) -> Self {
856         unsafe { ::std::mem::transmute(value) }
857     }
858 }
859 impl ::std::convert::From<&IDirectWriterLock> for ::windows::runtime::IUnknown {
from(value: &IDirectWriterLock) -> Self860     fn from(value: &IDirectWriterLock) -> Self {
861         ::std::convert::From::from(::std::clone::Clone::clone(value))
862     }
863 }
864 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDirectWriterLock {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>865     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
866         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
867     }
868 }
869 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDirectWriterLock {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>870     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
871         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
872     }
873 }
874 #[repr(C)]
875 #[doc(hidden)]
876 pub struct IDirectWriterLock_abi(
877     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
878     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
879     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
880     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwtimeout: u32) -> ::windows::runtime::HRESULT,
881     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
882     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
883 );
884 #[repr(transparent)]
885 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
886 pub struct IEnumSTATPROPSETSTG(::windows::runtime::IUnknown);
887 impl IEnumSTATPROPSETSTG {
888     #[cfg(feature = "Win32_Foundation")]
Next(&self, celt: u32, rgelt: *mut STATPROPSETSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>889     pub unsafe fn Next(&self, celt: u32, rgelt: *mut STATPROPSETSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
890         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
891     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>892     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
893         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
894     }
Reset(&self) -> ::windows::runtime::Result<()>895     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
896         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
897     }
Clone(&self) -> ::windows::runtime::Result<IEnumSTATPROPSETSTG>898     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumSTATPROPSETSTG> {
899         let mut result__: <IEnumSTATPROPSETSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
900         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSTATPROPSETSTG>(result__)
901     }
902 }
903 unsafe impl ::windows::runtime::Interface for IEnumSTATPROPSETSTG {
904     type Vtable = IEnumSTATPROPSETSTG_abi;
905     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(315, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
906 }
907 impl ::std::convert::From<IEnumSTATPROPSETSTG> for ::windows::runtime::IUnknown {
from(value: IEnumSTATPROPSETSTG) -> Self908     fn from(value: IEnumSTATPROPSETSTG) -> Self {
909         unsafe { ::std::mem::transmute(value) }
910     }
911 }
912 impl ::std::convert::From<&IEnumSTATPROPSETSTG> for ::windows::runtime::IUnknown {
from(value: &IEnumSTATPROPSETSTG) -> Self913     fn from(value: &IEnumSTATPROPSETSTG) -> Self {
914         ::std::convert::From::from(::std::clone::Clone::clone(value))
915     }
916 }
917 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumSTATPROPSETSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>918     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
919         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
920     }
921 }
922 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumSTATPROPSETSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>923     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
924         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
925     }
926 }
927 #[repr(C)]
928 #[doc(hidden)]
929 pub struct IEnumSTATPROPSETSTG_abi(
930     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
931     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
932     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
933     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut STATPROPSETSTG, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
934     #[cfg(not(feature = "Win32_Foundation"))] usize,
935     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
936     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
937     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
938 );
939 #[repr(transparent)]
940 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
941 pub struct IEnumSTATPROPSTG(::windows::runtime::IUnknown);
942 impl IEnumSTATPROPSTG {
943     #[cfg(feature = "Win32_Foundation")]
Next(&self, celt: u32, rgelt: *mut STATPROPSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>944     pub unsafe fn Next(&self, celt: u32, rgelt: *mut STATPROPSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
945         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
946     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>947     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
948         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
949     }
Reset(&self) -> ::windows::runtime::Result<()>950     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
951         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
952     }
Clone(&self) -> ::windows::runtime::Result<IEnumSTATPROPSTG>953     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumSTATPROPSTG> {
954         let mut result__: <IEnumSTATPROPSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
955         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSTATPROPSTG>(result__)
956     }
957 }
958 unsafe impl ::windows::runtime::Interface for IEnumSTATPROPSTG {
959     type Vtable = IEnumSTATPROPSTG_abi;
960     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(313, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
961 }
962 impl ::std::convert::From<IEnumSTATPROPSTG> for ::windows::runtime::IUnknown {
from(value: IEnumSTATPROPSTG) -> Self963     fn from(value: IEnumSTATPROPSTG) -> Self {
964         unsafe { ::std::mem::transmute(value) }
965     }
966 }
967 impl ::std::convert::From<&IEnumSTATPROPSTG> for ::windows::runtime::IUnknown {
from(value: &IEnumSTATPROPSTG) -> Self968     fn from(value: &IEnumSTATPROPSTG) -> Self {
969         ::std::convert::From::from(::std::clone::Clone::clone(value))
970     }
971 }
972 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumSTATPROPSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>973     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
974         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
975     }
976 }
977 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumSTATPROPSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>978     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
979         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
980     }
981 }
982 #[repr(C)]
983 #[doc(hidden)]
984 pub struct IEnumSTATPROPSTG_abi(
985     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
986     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
987     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
988     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut STATPROPSTG, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
989     #[cfg(not(feature = "Win32_Foundation"))] usize,
990     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
991     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
992     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
993 );
994 #[repr(transparent)]
995 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
996 pub struct IEnumSTATSTG(::windows::runtime::IUnknown);
997 impl IEnumSTATSTG {
998     #[cfg(feature = "Win32_Foundation")]
Next(&self, celt: u32, rgelt: *mut super::STATSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>999     pub unsafe fn Next(&self, celt: u32, rgelt: *mut super::STATSTG, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
1000         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
1001     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>1002     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
1003         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
1004     }
Reset(&self) -> ::windows::runtime::Result<()>1005     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
1006         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
1007     }
Clone(&self) -> ::windows::runtime::Result<IEnumSTATSTG>1008     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumSTATSTG> {
1009         let mut result__: <IEnumSTATSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1010         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSTATSTG>(result__)
1011     }
1012 }
1013 unsafe impl ::windows::runtime::Interface for IEnumSTATSTG {
1014     type Vtable = IEnumSTATSTG_abi;
1015     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(13, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1016 }
1017 impl ::std::convert::From<IEnumSTATSTG> for ::windows::runtime::IUnknown {
from(value: IEnumSTATSTG) -> Self1018     fn from(value: IEnumSTATSTG) -> Self {
1019         unsafe { ::std::mem::transmute(value) }
1020     }
1021 }
1022 impl ::std::convert::From<&IEnumSTATSTG> for ::windows::runtime::IUnknown {
from(value: &IEnumSTATSTG) -> Self1023     fn from(value: &IEnumSTATSTG) -> Self {
1024         ::std::convert::From::from(::std::clone::Clone::clone(value))
1025     }
1026 }
1027 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumSTATSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1028     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1029         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1030     }
1031 }
1032 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumSTATSTG {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1033     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1034         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1035     }
1036 }
1037 #[repr(C)]
1038 #[doc(hidden)]
1039 pub struct IEnumSTATSTG_abi(
1040     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1041     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1042     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1043     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut super::STATSTG, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
1044     #[cfg(not(feature = "Win32_Foundation"))] usize,
1045     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
1046     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1047     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1048 );
1049 #[repr(transparent)]
1050 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1051 pub struct IFillLockBytes(::windows::runtime::IUnknown);
1052 impl IFillLockBytes {
FillAppend(&self, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32>1053     pub unsafe fn FillAppend(&self, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32> {
1054         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1055         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pv), ::std::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
1056     }
FillAt(&self, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32>1057     pub unsafe fn FillAt(&self, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32> {
1058         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1059         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(uloffset), ::std::mem::transmute(pv), ::std::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
1060     }
SetFillSize(&self, ulsize: u64) -> ::windows::runtime::Result<()>1061     pub unsafe fn SetFillSize(&self, ulsize: u64) -> ::windows::runtime::Result<()> {
1062         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulsize)).ok()
1063     }
1064     #[cfg(feature = "Win32_Foundation")]
Terminate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, bcanceled: Param0) -> ::windows::runtime::Result<()>1065     pub unsafe fn Terminate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, bcanceled: Param0) -> ::windows::runtime::Result<()> {
1066         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), bcanceled.into_param().abi()).ok()
1067     }
1068 }
1069 unsafe impl ::windows::runtime::Interface for IFillLockBytes {
1070     type Vtable = IFillLockBytes_abi;
1071     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2580213776, 16734, 4559, [136, 20, 0, 170, 0, 181, 105, 245]);
1072 }
1073 impl ::std::convert::From<IFillLockBytes> for ::windows::runtime::IUnknown {
from(value: IFillLockBytes) -> Self1074     fn from(value: IFillLockBytes) -> Self {
1075         unsafe { ::std::mem::transmute(value) }
1076     }
1077 }
1078 impl ::std::convert::From<&IFillLockBytes> for ::windows::runtime::IUnknown {
from(value: &IFillLockBytes) -> Self1079     fn from(value: &IFillLockBytes) -> Self {
1080         ::std::convert::From::from(::std::clone::Clone::clone(value))
1081     }
1082 }
1083 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IFillLockBytes {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1084     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1085         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1086     }
1087 }
1088 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IFillLockBytes {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1089     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1090         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1091     }
1092 }
1093 #[repr(C)]
1094 #[doc(hidden)]
1095 pub struct IFillLockBytes_abi(
1096     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1097     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1098     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1099     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pv: *const ::std::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::runtime::HRESULT,
1100     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::runtime::HRESULT,
1101     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulsize: u64) -> ::windows::runtime::HRESULT,
1102     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bcanceled: super::super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
1103     #[cfg(not(feature = "Win32_Foundation"))] usize,
1104 );
1105 #[repr(transparent)]
1106 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1107 pub struct ILayoutStorage(::windows::runtime::IUnknown);
1108 impl ILayoutStorage {
1109     #[cfg(feature = "Win32_Foundation")]
LayoutScript(&self, pstoragelayout: *const super::StorageLayout, nentries: u32, glfinterleavedflag: u32) -> ::windows::runtime::Result<()>1110     pub unsafe fn LayoutScript(&self, pstoragelayout: *const super::StorageLayout, nentries: u32, glfinterleavedflag: u32) -> ::windows::runtime::Result<()> {
1111         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pstoragelayout), ::std::mem::transmute(nentries), ::std::mem::transmute(glfinterleavedflag)).ok()
1112     }
BeginMonitor(&self) -> ::windows::runtime::Result<()>1113     pub unsafe fn BeginMonitor(&self) -> ::windows::runtime::Result<()> {
1114         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self)).ok()
1115     }
EndMonitor(&self) -> ::windows::runtime::Result<()>1116     pub unsafe fn EndMonitor(&self) -> ::windows::runtime::Result<()> {
1117         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
1118     }
1119     #[cfg(feature = "Win32_Foundation")]
ReLayoutDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsnewdfname: Param0) -> ::windows::runtime::Result<()>1120     pub unsafe fn ReLayoutDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsnewdfname: Param0) -> ::windows::runtime::Result<()> {
1121         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), pwcsnewdfname.into_param().abi()).ok()
1122     }
ReLayoutDocfileOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(&self, pilockbytes: Param0) -> ::windows::runtime::Result<()>1123     pub unsafe fn ReLayoutDocfileOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(&self, pilockbytes: Param0) -> ::windows::runtime::Result<()> {
1124         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), pilockbytes.into_param().abi()).ok()
1125     }
1126 }
1127 unsafe impl ::windows::runtime::Interface for ILayoutStorage {
1128     type Vtable = ILayoutStorage_abi;
1129     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(242044304, 26424, 4559, [150, 8, 0, 170, 0, 104, 13, 180]);
1130 }
1131 impl ::std::convert::From<ILayoutStorage> for ::windows::runtime::IUnknown {
from(value: ILayoutStorage) -> Self1132     fn from(value: ILayoutStorage) -> Self {
1133         unsafe { ::std::mem::transmute(value) }
1134     }
1135 }
1136 impl ::std::convert::From<&ILayoutStorage> for ::windows::runtime::IUnknown {
from(value: &ILayoutStorage) -> Self1137     fn from(value: &ILayoutStorage) -> Self {
1138         ::std::convert::From::from(::std::clone::Clone::clone(value))
1139     }
1140 }
1141 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ILayoutStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1142     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1143         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1144     }
1145 }
1146 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ILayoutStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1147     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1148         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1149     }
1150 }
1151 #[repr(C)]
1152 #[doc(hidden)]
1153 pub struct ILayoutStorage_abi(
1154     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1155     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1156     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1157     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstoragelayout: *const super::StorageLayout, nentries: u32, glfinterleavedflag: u32) -> ::windows::runtime::HRESULT,
1158     #[cfg(not(feature = "Win32_Foundation"))] usize,
1159     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1160     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1161     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsnewdfname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1162     #[cfg(not(feature = "Win32_Foundation"))] usize,
1163     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pilockbytes: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1164 );
1165 #[repr(transparent)]
1166 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1167 pub struct ILockBytes(::windows::runtime::IUnknown);
1168 impl ILockBytes {
ReadAt(&self, uloffset: u64, pv: *mut ::std::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::runtime::Result<()>1169     pub unsafe fn ReadAt(&self, uloffset: u64, pv: *mut ::std::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::runtime::Result<()> {
1170         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(uloffset), ::std::mem::transmute(pv), ::std::mem::transmute(cb), ::std::mem::transmute(pcbread)).ok()
1171     }
WriteAt(&self, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32>1172     pub unsafe fn WriteAt(&self, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32) -> ::windows::runtime::Result<u32> {
1173         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1174         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(uloffset), ::std::mem::transmute(pv), ::std::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
1175     }
Flush(&self) -> ::windows::runtime::Result<()>1176     pub unsafe fn Flush(&self) -> ::windows::runtime::Result<()> {
1177         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
1178     }
SetSize(&self, cb: u64) -> ::windows::runtime::Result<()>1179     pub unsafe fn SetSize(&self, cb: u64) -> ::windows::runtime::Result<()> {
1180         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(cb)).ok()
1181     }
LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::Result<()>1182     pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::Result<()> {
1183         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(liboffset), ::std::mem::transmute(cb), ::std::mem::transmute(dwlocktype)).ok()
1184     }
UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::Result<()>1185     pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::Result<()> {
1186         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(liboffset), ::std::mem::transmute(cb), ::std::mem::transmute(dwlocktype)).ok()
1187     }
1188     #[cfg(feature = "Win32_Foundation")]
Stat(&self, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::Result<()>1189     pub unsafe fn Stat(&self, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::Result<()> {
1190         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pstatstg), ::std::mem::transmute(grfstatflag)).ok()
1191     }
1192 }
1193 unsafe impl ::windows::runtime::Interface for ILockBytes {
1194     type Vtable = ILockBytes_abi;
1195     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(10, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1196 }
1197 impl ::std::convert::From<ILockBytes> for ::windows::runtime::IUnknown {
from(value: ILockBytes) -> Self1198     fn from(value: ILockBytes) -> Self {
1199         unsafe { ::std::mem::transmute(value) }
1200     }
1201 }
1202 impl ::std::convert::From<&ILockBytes> for ::windows::runtime::IUnknown {
from(value: &ILockBytes) -> Self1203     fn from(value: &ILockBytes) -> Self {
1204         ::std::convert::From::from(::std::clone::Clone::clone(value))
1205     }
1206 }
1207 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ILockBytes {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1208     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1209         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1210     }
1211 }
1212 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ILockBytes {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1213     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1214         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1215     }
1216 }
1217 #[repr(C)]
1218 #[doc(hidden)]
1219 pub struct ILockBytes_abi(
1220     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1221     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1222     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1223     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uloffset: u64, pv: *mut ::std::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::runtime::HRESULT,
1224     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uloffset: u64, pv: *const ::std::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::runtime::HRESULT,
1225     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1226     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cb: u64) -> ::windows::runtime::HRESULT,
1227     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::HRESULT,
1228     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::runtime::HRESULT,
1229     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::HRESULT,
1230     #[cfg(not(feature = "Win32_Foundation"))] usize,
1231 );
1232 #[repr(transparent)]
1233 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1234 pub struct IPersistStorage(::windows::runtime::IUnknown);
1235 impl IPersistStorage {
GetClassID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>1236     pub unsafe fn GetClassID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
1237         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1238         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
1239     }
IsDirty(&self) -> ::windows::runtime::Result<()>1240     pub unsafe fn IsDirty(&self) -> ::windows::runtime::Result<()> {
1241         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self)).ok()
1242     }
InitNew<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstg: Param0) -> ::windows::runtime::Result<()>1243     pub unsafe fn InitNew<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstg: Param0) -> ::windows::runtime::Result<()> {
1244         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), pstg.into_param().abi()).ok()
1245     }
Load<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstg: Param0) -> ::windows::runtime::Result<()>1246     pub unsafe fn Load<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstg: Param0) -> ::windows::runtime::Result<()> {
1247         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), pstg.into_param().abi()).ok()
1248     }
1249     #[cfg(feature = "Win32_Foundation")]
Save<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, pstgsave: Param0, fsameasload: Param1) -> ::windows::runtime::Result<()>1250     pub unsafe fn Save<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, pstgsave: Param0, fsameasload: Param1) -> ::windows::runtime::Result<()> {
1251         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), pstgsave.into_param().abi(), fsameasload.into_param().abi()).ok()
1252     }
SaveCompleted<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstgnew: Param0) -> ::windows::runtime::Result<()>1253     pub unsafe fn SaveCompleted<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pstgnew: Param0) -> ::windows::runtime::Result<()> {
1254         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), pstgnew.into_param().abi()).ok()
1255     }
HandsOffStorage(&self) -> ::windows::runtime::Result<()>1256     pub unsafe fn HandsOffStorage(&self) -> ::windows::runtime::Result<()> {
1257         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self)).ok()
1258     }
1259 }
1260 unsafe impl ::windows::runtime::Interface for IPersistStorage {
1261     type Vtable = IPersistStorage_abi;
1262     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(266, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1263 }
1264 impl ::std::convert::From<IPersistStorage> for ::windows::runtime::IUnknown {
from(value: IPersistStorage) -> Self1265     fn from(value: IPersistStorage) -> Self {
1266         unsafe { ::std::mem::transmute(value) }
1267     }
1268 }
1269 impl ::std::convert::From<&IPersistStorage> for ::windows::runtime::IUnknown {
from(value: &IPersistStorage) -> Self1270     fn from(value: &IPersistStorage) -> Self {
1271         ::std::convert::From::from(::std::clone::Clone::clone(value))
1272     }
1273 }
1274 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPersistStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1275     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1276         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1277     }
1278 }
1279 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPersistStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1280     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1281         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1282     }
1283 }
1284 impl ::std::convert::From<IPersistStorage> for super::IPersist {
from(value: IPersistStorage) -> Self1285     fn from(value: IPersistStorage) -> Self {
1286         unsafe { ::std::mem::transmute(value) }
1287     }
1288 }
1289 impl ::std::convert::From<&IPersistStorage> for super::IPersist {
from(value: &IPersistStorage) -> Self1290     fn from(value: &IPersistStorage) -> Self {
1291         ::std::convert::From::from(::std::clone::Clone::clone(value))
1292     }
1293 }
1294 impl<'a> ::windows::runtime::IntoParam<'a, super::IPersist> for IPersistStorage {
into_param(self) -> ::windows::runtime::Param<'a, super::IPersist>1295     fn into_param(self) -> ::windows::runtime::Param<'a, super::IPersist> {
1296         ::windows::runtime::Param::Owned(::std::convert::Into::<super::IPersist>::into(self))
1297     }
1298 }
1299 impl<'a> ::windows::runtime::IntoParam<'a, super::IPersist> for &IPersistStorage {
into_param(self) -> ::windows::runtime::Param<'a, super::IPersist>1300     fn into_param(self) -> ::windows::runtime::Param<'a, super::IPersist> {
1301         ::windows::runtime::Param::Owned(::std::convert::Into::<super::IPersist>::into(::std::clone::Clone::clone(self)))
1302     }
1303 }
1304 #[repr(C)]
1305 #[doc(hidden)]
1306 pub struct IPersistStorage_abi(
1307     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1308     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1309     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1310     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pclassid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
1311     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1312     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstg: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1313     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstg: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1314     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstgsave: ::windows::runtime::RawPtr, fsameasload: super::super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
1315     #[cfg(not(feature = "Win32_Foundation"))] usize,
1316     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstgnew: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1317     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1318 );
1319 #[repr(transparent)]
1320 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1321 pub struct IPropertySetStorage(::windows::runtime::IUnknown);
1322 impl IPropertySetStorage {
Create(&self, rfmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, grfmode: u32) -> ::windows::runtime::Result<IPropertyStorage>1323     pub unsafe fn Create(&self, rfmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, grfmode: u32) -> ::windows::runtime::Result<IPropertyStorage> {
1324         let mut result__: <IPropertyStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1325         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(rfmtid), ::std::mem::transmute(pclsid), ::std::mem::transmute(grfflags), ::std::mem::transmute(grfmode), &mut result__).from_abi::<IPropertyStorage>(result__)
1326     }
Open(&self, rfmtid: *const ::windows::runtime::GUID, grfmode: u32) -> ::windows::runtime::Result<IPropertyStorage>1327     pub unsafe fn Open(&self, rfmtid: *const ::windows::runtime::GUID, grfmode: u32) -> ::windows::runtime::Result<IPropertyStorage> {
1328         let mut result__: <IPropertyStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1329         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(rfmtid), ::std::mem::transmute(grfmode), &mut result__).from_abi::<IPropertyStorage>(result__)
1330     }
Delete(&self, rfmtid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()>1331     pub unsafe fn Delete(&self, rfmtid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
1332         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(rfmtid)).ok()
1333     }
Enum(&self) -> ::windows::runtime::Result<IEnumSTATPROPSETSTG>1334     pub unsafe fn Enum(&self) -> ::windows::runtime::Result<IEnumSTATPROPSETSTG> {
1335         let mut result__: <IEnumSTATPROPSETSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1336         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSTATPROPSETSTG>(result__)
1337     }
1338 }
1339 unsafe impl ::windows::runtime::Interface for IPropertySetStorage {
1340     type Vtable = IPropertySetStorage_abi;
1341     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(314, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1342 }
1343 impl ::std::convert::From<IPropertySetStorage> for ::windows::runtime::IUnknown {
from(value: IPropertySetStorage) -> Self1344     fn from(value: IPropertySetStorage) -> Self {
1345         unsafe { ::std::mem::transmute(value) }
1346     }
1347 }
1348 impl ::std::convert::From<&IPropertySetStorage> for ::windows::runtime::IUnknown {
from(value: &IPropertySetStorage) -> Self1349     fn from(value: &IPropertySetStorage) -> Self {
1350         ::std::convert::From::from(::std::clone::Clone::clone(value))
1351     }
1352 }
1353 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPropertySetStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1354     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1355         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1356     }
1357 }
1358 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPropertySetStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1359     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1360         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1361     }
1362 }
1363 #[repr(C)]
1364 #[doc(hidden)]
1365 pub struct IPropertySetStorage_abi(
1366     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1367     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1368     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1369     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, rfmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, grfmode: u32, ppprstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1370     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, rfmtid: *const ::windows::runtime::GUID, grfmode: u32, ppprstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1371     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, rfmtid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
1372     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1373 );
1374 #[repr(transparent)]
1375 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1376 pub struct IPropertyStorage(::windows::runtime::IUnknown);
1377 impl IPropertyStorage {
1378     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows::runtime::Result<()>1379     pub unsafe fn ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows::runtime::Result<()> {
1380         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpspec), ::std::mem::transmute(rgpspec), ::std::mem::transmute(rgpropvar)).ok()
1381     }
1382     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows::runtime::Result<()>1383     pub unsafe fn WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows::runtime::Result<()> {
1384         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpspec), ::std::mem::transmute(rgpspec), ::std::mem::transmute(rgpropvar), ::std::mem::transmute(propidnamefirst)).ok()
1385     }
1386     #[cfg(feature = "Win32_Foundation")]
DeleteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC) -> ::windows::runtime::Result<()>1387     pub unsafe fn DeleteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC) -> ::windows::runtime::Result<()> {
1388         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpspec), ::std::mem::transmute(rgpspec)).ok()
1389     }
1390     #[cfg(feature = "Win32_Foundation")]
ReadPropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()>1391     pub unsafe fn ReadPropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
1392         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpropid), ::std::mem::transmute(rgpropid), ::std::mem::transmute(rglpwstrname)).ok()
1393     }
1394     #[cfg(feature = "Win32_Foundation")]
WritePropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()>1395     pub unsafe fn WritePropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
1396         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpropid), ::std::mem::transmute(rgpropid), ::std::mem::transmute(rglpwstrname)).ok()
1397     }
DeletePropertyNames(&self, cpropid: u32, rgpropid: *const u32) -> ::windows::runtime::Result<()>1398     pub unsafe fn DeletePropertyNames(&self, cpropid: u32, rgpropid: *const u32) -> ::windows::runtime::Result<()> {
1399         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(cpropid), ::std::mem::transmute(rgpropid)).ok()
1400     }
Commit(&self, grfcommitflags: u32) -> ::windows::runtime::Result<()>1401     pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::runtime::Result<()> {
1402         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfcommitflags)).ok()
1403     }
Revert(&self) -> ::windows::runtime::Result<()>1404     pub unsafe fn Revert(&self) -> ::windows::runtime::Result<()> {
1405         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self)).ok()
1406     }
Enum(&self) -> ::windows::runtime::Result<IEnumSTATPROPSTG>1407     pub unsafe fn Enum(&self) -> ::windows::runtime::Result<IEnumSTATPROPSTG> {
1408         let mut result__: <IEnumSTATPROPSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1409         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSTATPROPSTG>(result__)
1410     }
1411     #[cfg(feature = "Win32_Foundation")]
SetTimes(&self, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()>1412     pub unsafe fn SetTimes(&self, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()> {
1413         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(pctime), ::std::mem::transmute(patime), ::std::mem::transmute(pmtime)).ok()
1414     }
SetClass(&self, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()>1415     pub unsafe fn SetClass(&self, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
1416         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(clsid)).ok()
1417     }
1418     #[cfg(feature = "Win32_Foundation")]
Stat(&self) -> ::windows::runtime::Result<STATPROPSETSTG>1419     pub unsafe fn Stat(&self) -> ::windows::runtime::Result<STATPROPSETSTG> {
1420         let mut result__: <STATPROPSETSTG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1421         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<STATPROPSETSTG>(result__)
1422     }
1423 }
1424 unsafe impl ::windows::runtime::Interface for IPropertyStorage {
1425     type Vtable = IPropertyStorage_abi;
1426     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(312, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1427 }
1428 impl ::std::convert::From<IPropertyStorage> for ::windows::runtime::IUnknown {
from(value: IPropertyStorage) -> Self1429     fn from(value: IPropertyStorage) -> Self {
1430         unsafe { ::std::mem::transmute(value) }
1431     }
1432 }
1433 impl ::std::convert::From<&IPropertyStorage> for ::windows::runtime::IUnknown {
from(value: &IPropertyStorage) -> Self1434     fn from(value: &IPropertyStorage) -> Self {
1435         ::std::convert::From::from(::std::clone::Clone::clone(value))
1436     }
1437 }
1438 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPropertyStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1439     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1440         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1441     }
1442 }
1443 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPropertyStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1444     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1445         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1446     }
1447 }
1448 #[repr(C)]
1449 #[doc(hidden)]
1450 pub struct IPropertyStorage_abi(
1451     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1452     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1453     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1454     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut ::std::mem::ManuallyDrop<PROPVARIANT>) -> ::windows::runtime::HRESULT,
1455     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation")))] usize,
1456     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const ::std::mem::ManuallyDrop<PROPVARIANT>, propidnamefirst: u32) -> ::windows::runtime::HRESULT,
1457     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation")))] usize,
1458     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpspec: u32, rgpspec: *const PROPSPEC) -> ::windows::runtime::HRESULT,
1459     #[cfg(not(feature = "Win32_Foundation"))] usize,
1460     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1461     #[cfg(not(feature = "Win32_Foundation"))] usize,
1462     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1463     #[cfg(not(feature = "Win32_Foundation"))] usize,
1464     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cpropid: u32, rgpropid: *const u32) -> ::windows::runtime::HRESULT,
1465     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfcommitflags: u32) -> ::windows::runtime::HRESULT,
1466     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1467     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1468     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
1469     #[cfg(not(feature = "Win32_Foundation"))] usize,
1470     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
1471     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstatpsstg: *mut STATPROPSETSTG) -> ::windows::runtime::HRESULT,
1472     #[cfg(not(feature = "Win32_Foundation"))] usize,
1473 );
1474 #[repr(transparent)]
1475 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1476 pub struct IRootStorage(::windows::runtime::IUnknown);
1477 impl IRootStorage {
1478     #[cfg(feature = "Win32_Foundation")]
SwitchToFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszfile: Param0) -> ::windows::runtime::Result<()>1479     pub unsafe fn SwitchToFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszfile: Param0) -> ::windows::runtime::Result<()> {
1480         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), pszfile.into_param().abi()).ok()
1481     }
1482 }
1483 unsafe impl ::windows::runtime::Interface for IRootStorage {
1484     type Vtable = IRootStorage_abi;
1485     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(18, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1486 }
1487 impl ::std::convert::From<IRootStorage> for ::windows::runtime::IUnknown {
from(value: IRootStorage) -> Self1488     fn from(value: IRootStorage) -> Self {
1489         unsafe { ::std::mem::transmute(value) }
1490     }
1491 }
1492 impl ::std::convert::From<&IRootStorage> for ::windows::runtime::IUnknown {
from(value: &IRootStorage) -> Self1493     fn from(value: &IRootStorage) -> Self {
1494         ::std::convert::From::from(::std::clone::Clone::clone(value))
1495     }
1496 }
1497 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IRootStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1498     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1499         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1500     }
1501 }
1502 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IRootStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1503     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1504         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1505     }
1506 }
1507 #[repr(C)]
1508 #[doc(hidden)]
1509 pub struct IRootStorage_abi(
1510     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1511     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1512     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1513     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszfile: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1514     #[cfg(not(feature = "Win32_Foundation"))] usize,
1515 );
1516 #[repr(transparent)]
1517 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1518 pub struct IStorage(::windows::runtime::IUnknown);
1519 impl IStorage {
1520     #[cfg(feature = "Win32_Foundation")]
CreateStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, grfmode: u32, reserved1: u32, reserved2: u32) -> ::windows::runtime::Result<super::IStream>1521     pub unsafe fn CreateStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, grfmode: u32, reserved1: u32, reserved2: u32) -> ::windows::runtime::Result<super::IStream> {
1522         let mut result__: <super::IStream as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1523         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved1), ::std::mem::transmute(reserved2), &mut result__).from_abi::<super::IStream>(result__)
1524     }
1525     #[cfg(feature = "Win32_Foundation")]
OpenStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, reserved1: *mut ::std::ffi::c_void, grfmode: u32, reserved2: u32, ppstm: *mut ::std::option::Option<super::IStream>) -> ::windows::runtime::Result<()>1526     pub unsafe fn OpenStream<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, reserved1: *mut ::std::ffi::c_void, grfmode: u32, reserved2: u32, ppstm: *mut ::std::option::Option<super::IStream>) -> ::windows::runtime::Result<()> {
1527         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), ::std::mem::transmute(reserved1), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved2), ::std::mem::transmute(ppstm)).ok()
1528     }
1529     #[cfg(feature = "Win32_Foundation")]
CreateStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, grfmode: u32, reserved1: u32, reserved2: u32) -> ::windows::runtime::Result<IStorage>1530     pub unsafe fn CreateStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, grfmode: u32, reserved1: u32, reserved2: u32) -> ::windows::runtime::Result<IStorage> {
1531         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1532         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved1), ::std::mem::transmute(reserved2), &mut result__).from_abi::<IStorage>(result__)
1533     }
1534     #[cfg(feature = "Win32_Foundation")]
OpenStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pwcsname: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage>1535     pub unsafe fn OpenStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(&self, pwcsname: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage> {
1536         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1537         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), pstgpriority.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(snbexclude), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
1538     }
CopyTo<'a, Param3: ::windows::runtime::IntoParam<'a, IStorage>>(&self, ciidexclude: u32, rgiidexclude: *const ::windows::runtime::GUID, snbexclude: *const *const u16, pstgdest: Param3) -> ::windows::runtime::Result<()>1539     pub unsafe fn CopyTo<'a, Param3: ::windows::runtime::IntoParam<'a, IStorage>>(&self, ciidexclude: u32, rgiidexclude: *const ::windows::runtime::GUID, snbexclude: *const *const u16, pstgdest: Param3) -> ::windows::runtime::Result<()> {
1540         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(ciidexclude), ::std::mem::transmute(rgiidexclude), ::std::mem::transmute(snbexclude), pstgdest.into_param().abi()).ok()
1541     }
1542     #[cfg(feature = "Win32_Foundation")]
MoveElementTo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, pstgdest: Param1, pwcsnewname: Param2, grfflags: u32) -> ::windows::runtime::Result<()>1543     pub unsafe fn MoveElementTo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, pstgdest: Param1, pwcsnewname: Param2, grfflags: u32) -> ::windows::runtime::Result<()> {
1544         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), pstgdest.into_param().abi(), pwcsnewname.into_param().abi(), ::std::mem::transmute(grfflags)).ok()
1545     }
Commit(&self, grfcommitflags: u32) -> ::windows::runtime::Result<()>1546     pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::runtime::Result<()> {
1547         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfcommitflags)).ok()
1548     }
Revert(&self) -> ::windows::runtime::Result<()>1549     pub unsafe fn Revert(&self) -> ::windows::runtime::Result<()> {
1550         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self)).ok()
1551     }
EnumElements(&self, reserved1: u32, reserved2: *mut ::std::ffi::c_void, reserved3: u32, ppenum: *mut ::std::option::Option<IEnumSTATSTG>) -> ::windows::runtime::Result<()>1552     pub unsafe fn EnumElements(&self, reserved1: u32, reserved2: *mut ::std::ffi::c_void, reserved3: u32, ppenum: *mut ::std::option::Option<IEnumSTATSTG>) -> ::windows::runtime::Result<()> {
1553         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(reserved1), ::std::mem::transmute(reserved2), ::std::mem::transmute(reserved3), ::std::mem::transmute(ppenum)).ok()
1554     }
1555     #[cfg(feature = "Win32_Foundation")]
DestroyElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0) -> ::windows::runtime::Result<()>1556     pub unsafe fn DestroyElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0) -> ::windows::runtime::Result<()> {
1557         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), pwcsname.into_param().abi()).ok()
1558     }
1559     #[cfg(feature = "Win32_Foundation")]
RenameElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsoldname: Param0, pwcsnewname: Param1) -> ::windows::runtime::Result<()>1560     pub unsafe fn RenameElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsoldname: Param0, pwcsnewname: Param1) -> ::windows::runtime::Result<()> {
1561         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), pwcsoldname.into_param().abi(), pwcsnewname.into_param().abi()).ok()
1562     }
1563     #[cfg(feature = "Win32_Foundation")]
SetElementTimes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()>1564     pub unsafe fn SetElementTimes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwcsname: Param0, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()> {
1565         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), pwcsname.into_param().abi(), ::std::mem::transmute(pctime), ::std::mem::transmute(patime), ::std::mem::transmute(pmtime)).ok()
1566     }
SetClass(&self, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()>1567     pub unsafe fn SetClass(&self, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
1568         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), ::std::mem::transmute(clsid)).ok()
1569     }
SetStateBits(&self, grfstatebits: u32, grfmask: u32) -> ::windows::runtime::Result<()>1570     pub unsafe fn SetStateBits(&self, grfstatebits: u32, grfmask: u32) -> ::windows::runtime::Result<()> {
1571         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfstatebits), ::std::mem::transmute(grfmask)).ok()
1572     }
1573     #[cfg(feature = "Win32_Foundation")]
Stat(&self, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::Result<()>1574     pub unsafe fn Stat(&self, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::Result<()> {
1575         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(pstatstg), ::std::mem::transmute(grfstatflag)).ok()
1576     }
1577 }
1578 unsafe impl ::windows::runtime::Interface for IStorage {
1579     type Vtable = IStorage_abi;
1580     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(11, 0, 0, [192, 0, 0, 0, 0, 0, 0, 70]);
1581 }
1582 impl ::std::convert::From<IStorage> for ::windows::runtime::IUnknown {
from(value: IStorage) -> Self1583     fn from(value: IStorage) -> Self {
1584         unsafe { ::std::mem::transmute(value) }
1585     }
1586 }
1587 impl ::std::convert::From<&IStorage> for ::windows::runtime::IUnknown {
from(value: &IStorage) -> Self1588     fn from(value: &IStorage) -> Self {
1589         ::std::convert::From::from(::std::clone::Clone::clone(value))
1590     }
1591 }
1592 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1593     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1594         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1595     }
1596 }
1597 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IStorage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1598     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1599         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1600     }
1601 }
1602 #[repr(C)]
1603 #[doc(hidden)]
1604 pub struct IStorage_abi(
1605     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1606     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1607     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1608     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, grfmode: u32, reserved1: u32, reserved2: u32, ppstm: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1609     #[cfg(not(feature = "Win32_Foundation"))] usize,
1610     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, reserved1: *mut ::std::ffi::c_void, grfmode: u32, reserved2: u32, ppstm: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1611     #[cfg(not(feature = "Win32_Foundation"))] usize,
1612     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, grfmode: u32, reserved1: u32, reserved2: u32, ppstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1613     #[cfg(not(feature = "Win32_Foundation"))] usize,
1614     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, pstgpriority: ::windows::runtime::RawPtr, grfmode: u32, snbexclude: *const *const u16, reserved: u32, ppstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1615     #[cfg(not(feature = "Win32_Foundation"))] usize,
1616     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ciidexclude: u32, rgiidexclude: *const ::windows::runtime::GUID, snbexclude: *const *const u16, pstgdest: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1617     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, pstgdest: ::windows::runtime::RawPtr, pwcsnewname: super::super::super::Foundation::PWSTR, grfflags: u32) -> ::windows::runtime::HRESULT,
1618     #[cfg(not(feature = "Win32_Foundation"))] usize,
1619     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfcommitflags: u32) -> ::windows::runtime::HRESULT,
1620     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1621     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, reserved1: u32, reserved2: *mut ::std::ffi::c_void, reserved3: u32, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1622     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1623     #[cfg(not(feature = "Win32_Foundation"))] usize,
1624     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsoldname: super::super::super::Foundation::PWSTR, pwcsnewname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1625     #[cfg(not(feature = "Win32_Foundation"))] usize,
1626     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pwcsname: super::super::super::Foundation::PWSTR, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
1627     #[cfg(not(feature = "Win32_Foundation"))] usize,
1628     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, clsid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
1629     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfstatebits: u32, grfmask: u32) -> ::windows::runtime::HRESULT,
1630     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstatstg: *mut super::STATSTG, grfstatflag: u32) -> ::windows::runtime::HRESULT,
1631     #[cfg(not(feature = "Win32_Foundation"))] usize,
1632 );
1633 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1634 #[repr(transparent)]
1635 pub struct LOCKTYPE(pub i32);
1636 pub const LOCK_WRITE: LOCKTYPE = LOCKTYPE(1i32);
1637 pub const LOCK_EXCLUSIVE: LOCKTYPE = LOCKTYPE(2i32);
1638 pub const LOCK_ONLYONCE: LOCKTYPE = LOCKTYPE(4i32);
1639 impl ::std::convert::From<i32> for LOCKTYPE {
from(value: i32) -> Self1640     fn from(value: i32) -> Self {
1641         Self(value)
1642     }
1643 }
1644 unsafe impl ::windows::runtime::Abi for LOCKTYPE {
1645     type Abi = Self;
1646     type DefaultType = Self;
1647 }
1648 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1649 #[repr(C)]
1650 pub struct OLESTREAM {
1651     pub lpstbl: *mut OLESTREAMVTBL,
1652 }
1653 impl OLESTREAM {}
1654 impl ::std::default::Default for OLESTREAM {
default() -> Self1655     fn default() -> Self {
1656         unsafe { ::std::mem::zeroed() }
1657     }
1658 }
1659 impl ::std::fmt::Debug for OLESTREAM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1660     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1661         fmt.debug_struct("OLESTREAM").field("lpstbl", &self.lpstbl).finish()
1662     }
1663 }
1664 impl ::std::cmp::PartialEq for OLESTREAM {
eq(&self, other: &Self) -> bool1665     fn eq(&self, other: &Self) -> bool {
1666         self.lpstbl == other.lpstbl
1667     }
1668 }
1669 impl ::std::cmp::Eq for OLESTREAM {}
1670 unsafe impl ::windows::runtime::Abi for OLESTREAM {
1671     type Abi = Self;
1672     type DefaultType = Self;
1673 }
1674 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1675 #[repr(C)]
1676 pub struct OLESTREAMVTBL {
1677     pub Get: isize,
1678     pub Put: isize,
1679 }
1680 impl OLESTREAMVTBL {}
1681 impl ::std::default::Default for OLESTREAMVTBL {
default() -> Self1682     fn default() -> Self {
1683         unsafe { ::std::mem::zeroed() }
1684     }
1685 }
1686 impl ::std::fmt::Debug for OLESTREAMVTBL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1687     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1688         fmt.debug_struct("OLESTREAMVTBL").field("Get", &self.Get).field("Put", &self.Put).finish()
1689     }
1690 }
1691 impl ::std::cmp::PartialEq for OLESTREAMVTBL {
eq(&self, other: &Self) -> bool1692     fn eq(&self, other: &Self) -> bool {
1693         self.Get == other.Get && self.Put == other.Put
1694     }
1695 }
1696 impl ::std::cmp::Eq for OLESTREAMVTBL {}
1697 unsafe impl ::windows::runtime::Abi for OLESTREAMVTBL {
1698     type Abi = Self;
1699     type DefaultType = Self;
1700 }
1701 #[inline]
OleConvertIStorageToOLESTREAM<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, lpolestream: *mut OLESTREAM) -> ::windows::runtime::Result<()>1702 pub unsafe fn OleConvertIStorageToOLESTREAM<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, lpolestream: *mut OLESTREAM) -> ::windows::runtime::Result<()> {
1703     #[cfg(windows)]
1704     {
1705         #[link(name = "windows")]
1706         extern "system" {
1707             fn OleConvertIStorageToOLESTREAM(pstg: ::windows::runtime::RawPtr, lpolestream: *mut OLESTREAM) -> ::windows::runtime::HRESULT;
1708         }
1709         OleConvertIStorageToOLESTREAM(pstg.into_param().abi(), ::std::mem::transmute(lpolestream)).ok()
1710     }
1711     #[cfg(not(windows))]
1712     unimplemented!("Unsupported target OS");
1713 }
1714 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1715 #[inline]
OleConvertIStorageToOLESTREAMEx<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, cfformat: u16, lwidth: i32, lheight: i32, dwsize: u32, pmedium: *mut super::STGMEDIUM, polestm: *mut OLESTREAM) -> ::windows::runtime::Result<()>1716 pub unsafe fn OleConvertIStorageToOLESTREAMEx<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, cfformat: u16, lwidth: i32, lheight: i32, dwsize: u32, pmedium: *mut super::STGMEDIUM, polestm: *mut OLESTREAM) -> ::windows::runtime::Result<()> {
1717     #[cfg(windows)]
1718     {
1719         #[link(name = "windows")]
1720         extern "system" {
1721             fn OleConvertIStorageToOLESTREAMEx(pstg: ::windows::runtime::RawPtr, cfformat: u16, lwidth: i32, lheight: i32, dwsize: u32, pmedium: *mut ::std::mem::ManuallyDrop<super::STGMEDIUM>, polestm: *mut OLESTREAM) -> ::windows::runtime::HRESULT;
1722         }
1723         OleConvertIStorageToOLESTREAMEx(pstg.into_param().abi(), ::std::mem::transmute(cfformat), ::std::mem::transmute(lwidth), ::std::mem::transmute(lheight), ::std::mem::transmute(dwsize), ::std::mem::transmute(pmedium), ::std::mem::transmute(polestm)).ok()
1724     }
1725     #[cfg(not(windows))]
1726     unimplemented!("Unsupported target OS");
1727 }
1728 #[inline]
OleConvertOLESTREAMToIStorage<'a, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(lpolestream: *mut OLESTREAM, pstg: Param1, ptd: *const super::DVTARGETDEVICE) -> ::windows::runtime::Result<()>1729 pub unsafe fn OleConvertOLESTREAMToIStorage<'a, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(lpolestream: *mut OLESTREAM, pstg: Param1, ptd: *const super::DVTARGETDEVICE) -> ::windows::runtime::Result<()> {
1730     #[cfg(windows)]
1731     {
1732         #[link(name = "windows")]
1733         extern "system" {
1734             fn OleConvertOLESTREAMToIStorage(lpolestream: *mut OLESTREAM, pstg: ::windows::runtime::RawPtr, ptd: *const super::DVTARGETDEVICE) -> ::windows::runtime::HRESULT;
1735         }
1736         OleConvertOLESTREAMToIStorage(::std::mem::transmute(lpolestream), pstg.into_param().abi(), ::std::mem::transmute(ptd)).ok()
1737     }
1738     #[cfg(not(windows))]
1739     unimplemented!("Unsupported target OS");
1740 }
1741 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
1742 #[inline]
OleConvertOLESTREAMToIStorageEx<'a, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(polestm: *mut OLESTREAM, pstg: Param1, pcfformat: *mut u16, plwwidth: *mut i32, plheight: *mut i32, pdwsize: *mut u32, pmedium: *mut super::STGMEDIUM) -> ::windows::runtime::Result<()>1743 pub unsafe fn OleConvertOLESTREAMToIStorageEx<'a, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(polestm: *mut OLESTREAM, pstg: Param1, pcfformat: *mut u16, plwwidth: *mut i32, plheight: *mut i32, pdwsize: *mut u32, pmedium: *mut super::STGMEDIUM) -> ::windows::runtime::Result<()> {
1744     #[cfg(windows)]
1745     {
1746         #[link(name = "windows")]
1747         extern "system" {
1748             fn OleConvertOLESTREAMToIStorageEx(polestm: *mut OLESTREAM, pstg: ::windows::runtime::RawPtr, pcfformat: *mut u16, plwwidth: *mut i32, plheight: *mut i32, pdwsize: *mut u32, pmedium: *mut ::std::mem::ManuallyDrop<super::STGMEDIUM>) -> ::windows::runtime::HRESULT;
1749         }
1750         OleConvertOLESTREAMToIStorageEx(::std::mem::transmute(polestm), pstg.into_param().abi(), ::std::mem::transmute(pcfformat), ::std::mem::transmute(plwwidth), ::std::mem::transmute(plheight), ::std::mem::transmute(pdwsize), ::std::mem::transmute(pmedium)).ok()
1751     }
1752     #[cfg(not(windows))]
1753     unimplemented!("Unsupported target OS");
1754 }
1755 pub const PIDDI_THUMBNAIL: i32 = 2i32;
1756 pub const PIDDSI_BYTECOUNT: u32 = 4u32;
1757 pub const PIDDSI_CATEGORY: u32 = 2u32;
1758 pub const PIDDSI_COMPANY: u32 = 15u32;
1759 pub const PIDDSI_DOCPARTS: u32 = 13u32;
1760 pub const PIDDSI_HEADINGPAIR: u32 = 12u32;
1761 pub const PIDDSI_HIDDENCOUNT: u32 = 9u32;
1762 pub const PIDDSI_LINECOUNT: u32 = 5u32;
1763 pub const PIDDSI_LINKSDIRTY: u32 = 16u32;
1764 pub const PIDDSI_MANAGER: u32 = 14u32;
1765 pub const PIDDSI_MMCLIPCOUNT: u32 = 10u32;
1766 pub const PIDDSI_NOTECOUNT: u32 = 8u32;
1767 pub const PIDDSI_PARCOUNT: u32 = 6u32;
1768 pub const PIDDSI_PRESFORMAT: u32 = 3u32;
1769 pub const PIDDSI_SCALE: u32 = 11u32;
1770 pub const PIDDSI_SLIDECOUNT: u32 = 7u32;
1771 pub const PIDMSI_COPYRIGHT: i32 = 11i32;
1772 pub const PIDMSI_EDITOR: i32 = 2i32;
1773 pub const PIDMSI_OWNER: i32 = 8i32;
1774 pub const PIDMSI_PRODUCTION: i32 = 10i32;
1775 pub const PIDMSI_PROJECT: i32 = 6i32;
1776 pub const PIDMSI_RATING: i32 = 9i32;
1777 pub const PIDMSI_SEQUENCE_NO: i32 = 5i32;
1778 pub const PIDMSI_SOURCE: i32 = 4i32;
1779 pub const PIDMSI_STATUS: i32 = 7i32;
1780 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1781 #[repr(transparent)]
1782 pub struct PIDMSI_STATUS_VALUE(pub i32);
1783 pub const PIDMSI_STATUS_NORMAL: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(0i32);
1784 pub const PIDMSI_STATUS_NEW: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(1i32);
1785 pub const PIDMSI_STATUS_PRELIM: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(2i32);
1786 pub const PIDMSI_STATUS_DRAFT: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(3i32);
1787 pub const PIDMSI_STATUS_INPROGRESS: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(4i32);
1788 pub const PIDMSI_STATUS_EDIT: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(5i32);
1789 pub const PIDMSI_STATUS_REVIEW: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(6i32);
1790 pub const PIDMSI_STATUS_PROOF: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(7i32);
1791 pub const PIDMSI_STATUS_FINAL: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(8i32);
1792 pub const PIDMSI_STATUS_OTHER: PIDMSI_STATUS_VALUE = PIDMSI_STATUS_VALUE(32767i32);
1793 impl ::std::convert::From<i32> for PIDMSI_STATUS_VALUE {
from(value: i32) -> Self1794     fn from(value: i32) -> Self {
1795         Self(value)
1796     }
1797 }
1798 unsafe impl ::windows::runtime::Abi for PIDMSI_STATUS_VALUE {
1799     type Abi = Self;
1800     type DefaultType = Self;
1801 }
1802 pub const PIDMSI_SUPPLIER: i32 = 3i32;
1803 pub const PIDSI_APPNAME: i32 = 18i32;
1804 pub const PIDSI_AUTHOR: i32 = 4i32;
1805 pub const PIDSI_CHARCOUNT: i32 = 16i32;
1806 pub const PIDSI_COMMENTS: i32 = 6i32;
1807 pub const PIDSI_CREATE_DTM: i32 = 12i32;
1808 pub const PIDSI_DOC_SECURITY: i32 = 19i32;
1809 pub const PIDSI_EDITTIME: i32 = 10i32;
1810 pub const PIDSI_KEYWORDS: i32 = 5i32;
1811 pub const PIDSI_LASTAUTHOR: i32 = 8i32;
1812 pub const PIDSI_LASTPRINTED: i32 = 11i32;
1813 pub const PIDSI_LASTSAVE_DTM: i32 = 13i32;
1814 pub const PIDSI_PAGECOUNT: i32 = 14i32;
1815 pub const PIDSI_REVNUMBER: i32 = 9i32;
1816 pub const PIDSI_SUBJECT: i32 = 3i32;
1817 pub const PIDSI_TEMPLATE: i32 = 7i32;
1818 pub const PIDSI_THUMBNAIL: i32 = 17i32;
1819 pub const PIDSI_TITLE: i32 = 2i32;
1820 pub const PIDSI_WORDCOUNT: i32 = 15i32;
1821 pub const PID_BEHAVIOR: u32 = 2147483651u32;
1822 pub const PID_CODEPAGE: u32 = 1u32;
1823 pub const PID_DICTIONARY: u32 = 0u32;
1824 pub const PID_FIRST_NAME_DEFAULT: u32 = 4095u32;
1825 pub const PID_FIRST_USABLE: u32 = 2u32;
1826 pub const PID_ILLEGAL: u32 = 4294967295u32;
1827 pub const PID_LOCALE: u32 = 2147483648u32;
1828 pub const PID_MAX_READONLY: u32 = 3221225471u32;
1829 pub const PID_MIN_READONLY: u32 = 2147483648u32;
1830 pub const PID_MODIFY_TIME: u32 = 2147483649u32;
1831 pub const PID_SECURITY: u32 = 2147483650u32;
1832 #[repr(C)]
1833 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
1834 pub struct PMemoryAllocator(pub u8);
1835 pub const PROPSETFLAG_ANSI: u32 = 2u32;
1836 pub const PROPSETFLAG_CASE_SENSITIVE: u32 = 8u32;
1837 pub const PROPSETFLAG_DEFAULT: u32 = 0u32;
1838 pub const PROPSETFLAG_NONSIMPLE: u32 = 1u32;
1839 pub const PROPSETFLAG_UNBUFFERED: u32 = 4u32;
1840 pub const PROPSETHDR_OSVERSION_UNKNOWN: u32 = 4294967295u32;
1841 pub const PROPSET_BEHAVIOR_CASE_SENSITIVE: u32 = 1u32;
1842 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1843 #[repr(C)]
1844 #[cfg(feature = "Win32_Foundation")]
1845 pub struct PROPSPEC {
1846     pub ulKind: PROPSPEC_KIND,
1847     pub Anonymous: PROPSPEC_0,
1848 }
1849 #[cfg(feature = "Win32_Foundation")]
1850 impl PROPSPEC {}
1851 #[cfg(feature = "Win32_Foundation")]
1852 impl ::std::default::Default for PROPSPEC {
default() -> Self1853     fn default() -> Self {
1854         unsafe { ::std::mem::zeroed() }
1855     }
1856 }
1857 #[cfg(feature = "Win32_Foundation")]
1858 impl ::std::cmp::PartialEq for PROPSPEC {
eq(&self, _other: &Self) -> bool1859     fn eq(&self, _other: &Self) -> bool {
1860         unimplemented!()
1861     }
1862 }
1863 #[cfg(feature = "Win32_Foundation")]
1864 impl ::std::cmp::Eq for PROPSPEC {}
1865 #[cfg(feature = "Win32_Foundation")]
1866 unsafe impl ::windows::runtime::Abi for PROPSPEC {
1867     type Abi = Self;
1868     type DefaultType = Self;
1869 }
1870 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1871 #[repr(C)]
1872 #[cfg(feature = "Win32_Foundation")]
1873 pub union PROPSPEC_0 {
1874     pub propid: u32,
1875     pub lpwstr: super::super::super::Foundation::PWSTR,
1876 }
1877 #[cfg(feature = "Win32_Foundation")]
1878 impl PROPSPEC_0 {}
1879 #[cfg(feature = "Win32_Foundation")]
1880 impl ::std::default::Default for PROPSPEC_0 {
default() -> Self1881     fn default() -> Self {
1882         unsafe { ::std::mem::zeroed() }
1883     }
1884 }
1885 #[cfg(feature = "Win32_Foundation")]
1886 impl ::std::cmp::PartialEq for PROPSPEC_0 {
eq(&self, _other: &Self) -> bool1887     fn eq(&self, _other: &Self) -> bool {
1888         unimplemented!()
1889     }
1890 }
1891 #[cfg(feature = "Win32_Foundation")]
1892 impl ::std::cmp::Eq for PROPSPEC_0 {}
1893 #[cfg(feature = "Win32_Foundation")]
1894 unsafe impl ::windows::runtime::Abi for PROPSPEC_0 {
1895     type Abi = Self;
1896     type DefaultType = Self;
1897 }
1898 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1899 #[repr(transparent)]
1900 pub struct PROPSPEC_KIND(pub u32);
1901 pub const PRSPEC_LPWSTR: PROPSPEC_KIND = PROPSPEC_KIND(0u32);
1902 pub const PRSPEC_PROPID: PROPSPEC_KIND = PROPSPEC_KIND(1u32);
1903 impl ::std::convert::From<u32> for PROPSPEC_KIND {
from(value: u32) -> Self1904     fn from(value: u32) -> Self {
1905         Self(value)
1906     }
1907 }
1908 unsafe impl ::windows::runtime::Abi for PROPSPEC_KIND {
1909     type Abi = Self;
1910     type DefaultType = Self;
1911 }
1912 impl ::std::ops::BitOr for PROPSPEC_KIND {
1913     type Output = Self;
bitor(self, rhs: Self) -> Self1914     fn bitor(self, rhs: Self) -> Self {
1915         Self(self.0 | rhs.0)
1916     }
1917 }
1918 impl ::std::ops::BitAnd for PROPSPEC_KIND {
1919     type Output = Self;
bitand(self, rhs: Self) -> Self1920     fn bitand(self, rhs: Self) -> Self {
1921         Self(self.0 & rhs.0)
1922     }
1923 }
1924 impl ::std::ops::BitOrAssign for PROPSPEC_KIND {
bitor_assign(&mut self, rhs: Self)1925     fn bitor_assign(&mut self, rhs: Self) {
1926         self.0.bitor_assign(rhs.0)
1927     }
1928 }
1929 impl ::std::ops::BitAndAssign for PROPSPEC_KIND {
bitand_assign(&mut self, rhs: Self)1930     fn bitand_assign(&mut self, rhs: Self) {
1931         self.0.bitand_assign(rhs.0)
1932     }
1933 }
1934 impl ::std::ops::Not for PROPSPEC_KIND {
1935     type Output = Self;
not(self) -> Self1936     fn not(self) -> Self {
1937         Self(self.0.not())
1938     }
1939 }
1940 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1941 impl ::std::clone::Clone for PROPVARIANT {
clone(&self) -> Self1942     fn clone(&self) -> Self {
1943         unimplemented!()
1944     }
1945 }
1946 #[repr(C)]
1947 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1948 pub struct PROPVARIANT {
1949     pub Anonymous: PROPVARIANT_0,
1950 }
1951 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1952 impl PROPVARIANT {}
1953 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1954 impl ::std::default::Default for PROPVARIANT {
default() -> Self1955     fn default() -> Self {
1956         unsafe { ::std::mem::zeroed() }
1957     }
1958 }
1959 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1960 impl ::std::cmp::PartialEq for PROPVARIANT {
eq(&self, _other: &Self) -> bool1961     fn eq(&self, _other: &Self) -> bool {
1962         unimplemented!()
1963     }
1964 }
1965 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1966 impl ::std::cmp::Eq for PROPVARIANT {}
1967 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1968 unsafe impl ::windows::runtime::Abi for PROPVARIANT {
1969     type Abi = ::std::mem::ManuallyDrop<Self>;
1970     type DefaultType = Self;
1971 }
1972 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1973 impl ::std::clone::Clone for PROPVARIANT_0 {
clone(&self) -> Self1974     fn clone(&self) -> Self {
1975         unimplemented!()
1976     }
1977 }
1978 #[repr(C)]
1979 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1980 pub union PROPVARIANT_0 {
1981     pub Anonymous: ::std::mem::ManuallyDrop<PROPVARIANT_0_0>,
1982     pub decVal: super::super::super::Foundation::DECIMAL,
1983 }
1984 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1985 impl PROPVARIANT_0 {}
1986 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1987 impl ::std::default::Default for PROPVARIANT_0 {
default() -> Self1988     fn default() -> Self {
1989         unsafe { ::std::mem::zeroed() }
1990     }
1991 }
1992 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1993 impl ::std::cmp::PartialEq for PROPVARIANT_0 {
eq(&self, _other: &Self) -> bool1994     fn eq(&self, _other: &Self) -> bool {
1995         unimplemented!()
1996     }
1997 }
1998 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
1999 impl ::std::cmp::Eq for PROPVARIANT_0 {}
2000 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2001 unsafe impl ::windows::runtime::Abi for PROPVARIANT_0 {
2002     type Abi = ::std::mem::ManuallyDrop<Self>;
2003     type DefaultType = Self;
2004 }
2005 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2006 impl ::std::clone::Clone for PROPVARIANT_0_0 {
clone(&self) -> Self2007     fn clone(&self) -> Self {
2008         unimplemented!()
2009     }
2010 }
2011 #[repr(C)]
2012 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2013 pub struct PROPVARIANT_0_0 {
2014     pub vt: u16,
2015     pub wReserved1: u16,
2016     pub wReserved2: u16,
2017     pub wReserved3: u16,
2018     pub Anonymous: PROPVARIANT_0_0_0,
2019 }
2020 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2021 impl PROPVARIANT_0_0 {}
2022 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2023 impl ::std::default::Default for PROPVARIANT_0_0 {
default() -> Self2024     fn default() -> Self {
2025         unsafe { ::std::mem::zeroed() }
2026     }
2027 }
2028 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2029 impl ::std::cmp::PartialEq for PROPVARIANT_0_0 {
eq(&self, _other: &Self) -> bool2030     fn eq(&self, _other: &Self) -> bool {
2031         unimplemented!()
2032     }
2033 }
2034 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2035 impl ::std::cmp::Eq for PROPVARIANT_0_0 {}
2036 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2037 unsafe impl ::windows::runtime::Abi for PROPVARIANT_0_0 {
2038     type Abi = ::std::mem::ManuallyDrop<Self>;
2039     type DefaultType = Self;
2040 }
2041 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2042 impl ::std::clone::Clone for PROPVARIANT_0_0_0 {
clone(&self) -> Self2043     fn clone(&self) -> Self {
2044         unimplemented!()
2045     }
2046 }
2047 #[repr(C)]
2048 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2049 pub union PROPVARIANT_0_0_0 {
2050     pub cVal: super::super::super::Foundation::CHAR,
2051     pub bVal: u8,
2052     pub iVal: i16,
2053     pub uiVal: u16,
2054     pub lVal: i32,
2055     pub ulVal: u32,
2056     pub intVal: i32,
2057     pub uintVal: u32,
2058     pub hVal: i64,
2059     pub uhVal: u64,
2060     pub fltVal: f32,
2061     pub dblVal: f64,
2062     pub boolVal: i16,
2063     pub __OBSOLETE__VARIANT_BOOL: i16,
2064     pub scode: i32,
2065     pub cyVal: super::CY,
2066     pub date: f64,
2067     pub filetime: super::super::super::Foundation::FILETIME,
2068     pub puuid: *mut ::windows::runtime::GUID,
2069     pub pclipdata: *mut CLIPDATA,
2070     pub bstrVal: ::std::mem::ManuallyDrop<super::super::super::Foundation::BSTR>,
2071     pub bstrblobVal: BSTRBLOB,
2072     pub blob: super::BLOB,
2073     pub pszVal: super::super::super::Foundation::PSTR,
2074     pub pwszVal: super::super::super::Foundation::PWSTR,
2075     pub punkVal: ::windows::runtime::RawPtr,
2076     pub pdispVal: ::windows::runtime::RawPtr,
2077     pub pStream: ::windows::runtime::RawPtr,
2078     pub pStorage: ::windows::runtime::RawPtr,
2079     pub pVersionedStream: *mut ::std::mem::ManuallyDrop<VERSIONEDSTREAM>,
2080     pub parray: *mut super::SAFEARRAY,
2081     pub cac: CAC,
2082     pub caub: CAUB,
2083     pub cai: CAI,
2084     pub caui: CAUI,
2085     pub cal: CAL,
2086     pub caul: CAUL,
2087     pub cah: CAH,
2088     pub cauh: CAUH,
2089     pub caflt: CAFLT,
2090     pub cadbl: CADBL,
2091     pub cabool: CABOOL,
2092     pub cascode: CASCODE,
2093     pub cacy: CACY,
2094     pub cadate: CADATE,
2095     pub cafiletime: CAFILETIME,
2096     pub cauuid: CACLSID,
2097     pub caclipdata: CACLIPDATA,
2098     pub cabstr: CABSTR,
2099     pub cabstrblob: CABSTRBLOB,
2100     pub calpstr: CALPSTR,
2101     pub calpwstr: CALPWSTR,
2102     pub capropvar: CAPROPVARIANT,
2103     pub pcVal: super::super::super::Foundation::PSTR,
2104     pub pbVal: *mut u8,
2105     pub piVal: *mut i16,
2106     pub puiVal: *mut u16,
2107     pub plVal: *mut i32,
2108     pub pulVal: *mut u32,
2109     pub pintVal: *mut i32,
2110     pub puintVal: *mut u32,
2111     pub pfltVal: *mut f32,
2112     pub pdblVal: *mut f64,
2113     pub pboolVal: *mut i16,
2114     pub pdecVal: *mut super::super::super::Foundation::DECIMAL,
2115     pub pscode: *mut i32,
2116     pub pcyVal: *mut super::CY,
2117     pub pdate: *mut f64,
2118     pub pbstrVal: *mut ::std::mem::ManuallyDrop<super::super::super::Foundation::BSTR>,
2119     pub ppunkVal: *mut ::windows::runtime::RawPtr,
2120     pub ppdispVal: *mut ::windows::runtime::RawPtr,
2121     pub pparray: *mut *mut super::SAFEARRAY,
2122     pub pvarVal: *mut ::std::mem::ManuallyDrop<PROPVARIANT>,
2123 }
2124 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2125 impl PROPVARIANT_0_0_0 {}
2126 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2127 impl ::std::default::Default for PROPVARIANT_0_0_0 {
default() -> Self2128     fn default() -> Self {
2129         unsafe { ::std::mem::zeroed() }
2130     }
2131 }
2132 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2133 impl ::std::cmp::PartialEq for PROPVARIANT_0_0_0 {
eq(&self, _other: &Self) -> bool2134     fn eq(&self, _other: &Self) -> bool {
2135         unimplemented!()
2136     }
2137 }
2138 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2139 impl ::std::cmp::Eq for PROPVARIANT_0_0_0 {}
2140 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2141 unsafe impl ::windows::runtime::Abi for PROPVARIANT_0_0_0 {
2142     type Abi = ::std::mem::ManuallyDrop<Self>;
2143     type DefaultType = Self;
2144 }
2145 pub const PRSPEC_INVALID: u32 = 4294967295u32;
2146 #[cfg(feature = "Win32_Foundation")]
2147 #[inline]
PropStgNameToFmtId<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(oszname: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID>2148 pub unsafe fn PropStgNameToFmtId<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(oszname: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID> {
2149     #[cfg(windows)]
2150     {
2151         #[link(name = "windows")]
2152         extern "system" {
2153             fn PropStgNameToFmtId(oszname: super::super::super::Foundation::PWSTR, pfmtid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
2154         }
2155         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2156         PropStgNameToFmtId(oszname.into_param().abi(), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
2157     }
2158     #[cfg(not(windows))]
2159     unimplemented!("Unsupported target OS");
2160 }
2161 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2162 #[inline]
PropVariantClear(pvar: *mut PROPVARIANT) -> ::windows::runtime::Result<()>2163 pub unsafe fn PropVariantClear(pvar: *mut PROPVARIANT) -> ::windows::runtime::Result<()> {
2164     #[cfg(windows)]
2165     {
2166         #[link(name = "windows")]
2167         extern "system" {
2168             fn PropVariantClear(pvar: *mut ::std::mem::ManuallyDrop<PROPVARIANT>) -> ::windows::runtime::HRESULT;
2169         }
2170         PropVariantClear(::std::mem::transmute(pvar)).ok()
2171     }
2172     #[cfg(not(windows))]
2173     unimplemented!("Unsupported target OS");
2174 }
2175 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2176 #[inline]
PropVariantCopy(pvardest: *mut PROPVARIANT, pvarsrc: *const PROPVARIANT) -> ::windows::runtime::Result<()>2177 pub unsafe fn PropVariantCopy(pvardest: *mut PROPVARIANT, pvarsrc: *const PROPVARIANT) -> ::windows::runtime::Result<()> {
2178     #[cfg(windows)]
2179     {
2180         #[link(name = "windows")]
2181         extern "system" {
2182             fn PropVariantCopy(pvardest: *mut ::std::mem::ManuallyDrop<PROPVARIANT>, pvarsrc: *const ::std::mem::ManuallyDrop<PROPVARIANT>) -> ::windows::runtime::HRESULT;
2183         }
2184         PropVariantCopy(::std::mem::transmute(pvardest), ::std::mem::transmute(pvarsrc)).ok()
2185     }
2186     #[cfg(not(windows))]
2187     unimplemented!("Unsupported target OS");
2188 }
2189 #[inline]
ReadClassStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID>2190 pub unsafe fn ReadClassStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID> {
2191     #[cfg(windows)]
2192     {
2193         #[link(name = "windows")]
2194         extern "system" {
2195             fn ReadClassStg(pstg: ::windows::runtime::RawPtr, pclsid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
2196         }
2197         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2198         ReadClassStg(pstg.into_param().abi(), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
2199     }
2200     #[cfg(not(windows))]
2201     unimplemented!("Unsupported target OS");
2202 }
2203 #[inline]
ReadClassStm<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID>2204 pub unsafe fn ReadClassStm<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0) -> ::windows::runtime::Result<::windows::runtime::GUID> {
2205     #[cfg(windows)]
2206     {
2207         #[link(name = "windows")]
2208         extern "system" {
2209             fn ReadClassStm(pstm: ::windows::runtime::RawPtr, pclsid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
2210         }
2211         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2212         ReadClassStm(pstm.into_param().abi(), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
2213     }
2214     #[cfg(not(windows))]
2215     unimplemented!("Unsupported target OS");
2216 }
2217 #[cfg(feature = "Win32_Foundation")]
2218 #[inline]
ReadFmtUserTypeStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, pcf: *mut u16, lplpszusertype: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()>2219 pub unsafe fn ReadFmtUserTypeStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, pcf: *mut u16, lplpszusertype: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
2220     #[cfg(windows)]
2221     {
2222         #[link(name = "windows")]
2223         extern "system" {
2224             fn ReadFmtUserTypeStg(pstg: ::windows::runtime::RawPtr, pcf: *mut u16, lplpszusertype: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
2225         }
2226         ReadFmtUserTypeStg(pstg.into_param().abi(), ::std::mem::transmute(pcf), ::std::mem::transmute(lplpszusertype)).ok()
2227     }
2228     #[cfg(not(windows))]
2229     unimplemented!("Unsupported target OS");
2230 }
2231 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2232 #[repr(C)]
2233 pub struct RemSNB {
2234     pub ulCntStr: u32,
2235     pub ulCntChar: u32,
2236     pub rgString: [u16; 1],
2237 }
2238 impl RemSNB {}
2239 impl ::std::default::Default for RemSNB {
default() -> Self2240     fn default() -> Self {
2241         unsafe { ::std::mem::zeroed() }
2242     }
2243 }
2244 impl ::std::fmt::Debug for RemSNB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2245     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2246         fmt.debug_struct("RemSNB").field("ulCntStr", &self.ulCntStr).field("ulCntChar", &self.ulCntChar).field("rgString", &self.rgString).finish()
2247     }
2248 }
2249 impl ::std::cmp::PartialEq for RemSNB {
eq(&self, other: &Self) -> bool2250     fn eq(&self, other: &Self) -> bool {
2251         self.ulCntStr == other.ulCntStr && self.ulCntChar == other.ulCntChar && self.rgString == other.rgString
2252     }
2253 }
2254 impl ::std::cmp::Eq for RemSNB {}
2255 unsafe impl ::windows::runtime::Abi for RemSNB {
2256     type Abi = Self;
2257     type DefaultType = Self;
2258 }
2259 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2260 #[repr(C)]
2261 pub struct SERIALIZEDPROPERTYVALUE {
2262     pub dwType: u32,
2263     pub rgb: [u8; 1],
2264 }
2265 impl SERIALIZEDPROPERTYVALUE {}
2266 impl ::std::default::Default for SERIALIZEDPROPERTYVALUE {
default() -> Self2267     fn default() -> Self {
2268         unsafe { ::std::mem::zeroed() }
2269     }
2270 }
2271 impl ::std::fmt::Debug for SERIALIZEDPROPERTYVALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2272     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2273         fmt.debug_struct("SERIALIZEDPROPERTYVALUE").field("dwType", &self.dwType).field("rgb", &self.rgb).finish()
2274     }
2275 }
2276 impl ::std::cmp::PartialEq for SERIALIZEDPROPERTYVALUE {
eq(&self, other: &Self) -> bool2277     fn eq(&self, other: &Self) -> bool {
2278         self.dwType == other.dwType && self.rgb == other.rgb
2279     }
2280 }
2281 impl ::std::cmp::Eq for SERIALIZEDPROPERTYVALUE {}
2282 unsafe impl ::windows::runtime::Abi for SERIALIZEDPROPERTYVALUE {
2283     type Abi = Self;
2284     type DefaultType = Self;
2285 }
2286 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2287 #[repr(transparent)]
2288 pub struct STATFLAG(pub i32);
2289 pub const STATFLAG_DEFAULT: STATFLAG = STATFLAG(0i32);
2290 pub const STATFLAG_NONAME: STATFLAG = STATFLAG(1i32);
2291 pub const STATFLAG_NOOPEN: STATFLAG = STATFLAG(2i32);
2292 impl ::std::convert::From<i32> for STATFLAG {
from(value: i32) -> Self2293     fn from(value: i32) -> Self {
2294         Self(value)
2295     }
2296 }
2297 unsafe impl ::windows::runtime::Abi for STATFLAG {
2298     type Abi = Self;
2299     type DefaultType = Self;
2300 }
2301 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2302 #[repr(C)]
2303 #[cfg(feature = "Win32_Foundation")]
2304 pub struct STATPROPSETSTG {
2305     pub fmtid: ::windows::runtime::GUID,
2306     pub clsid: ::windows::runtime::GUID,
2307     pub grfFlags: u32,
2308     pub mtime: super::super::super::Foundation::FILETIME,
2309     pub ctime: super::super::super::Foundation::FILETIME,
2310     pub atime: super::super::super::Foundation::FILETIME,
2311     pub dwOSVersion: u32,
2312 }
2313 #[cfg(feature = "Win32_Foundation")]
2314 impl STATPROPSETSTG {}
2315 #[cfg(feature = "Win32_Foundation")]
2316 impl ::std::default::Default for STATPROPSETSTG {
default() -> Self2317     fn default() -> Self {
2318         unsafe { ::std::mem::zeroed() }
2319     }
2320 }
2321 #[cfg(feature = "Win32_Foundation")]
2322 impl ::std::fmt::Debug for STATPROPSETSTG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2323     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2324         fmt.debug_struct("STATPROPSETSTG").field("fmtid", &self.fmtid).field("clsid", &self.clsid).field("grfFlags", &self.grfFlags).field("mtime", &self.mtime).field("ctime", &self.ctime).field("atime", &self.atime).field("dwOSVersion", &self.dwOSVersion).finish()
2325     }
2326 }
2327 #[cfg(feature = "Win32_Foundation")]
2328 impl ::std::cmp::PartialEq for STATPROPSETSTG {
eq(&self, other: &Self) -> bool2329     fn eq(&self, other: &Self) -> bool {
2330         self.fmtid == other.fmtid && self.clsid == other.clsid && self.grfFlags == other.grfFlags && self.mtime == other.mtime && self.ctime == other.ctime && self.atime == other.atime && self.dwOSVersion == other.dwOSVersion
2331     }
2332 }
2333 #[cfg(feature = "Win32_Foundation")]
2334 impl ::std::cmp::Eq for STATPROPSETSTG {}
2335 #[cfg(feature = "Win32_Foundation")]
2336 unsafe impl ::windows::runtime::Abi for STATPROPSETSTG {
2337     type Abi = Self;
2338     type DefaultType = Self;
2339 }
2340 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2341 #[repr(C)]
2342 #[cfg(feature = "Win32_Foundation")]
2343 pub struct STATPROPSTG {
2344     pub lpwstrName: super::super::super::Foundation::PWSTR,
2345     pub propid: u32,
2346     pub vt: u16,
2347 }
2348 #[cfg(feature = "Win32_Foundation")]
2349 impl STATPROPSTG {}
2350 #[cfg(feature = "Win32_Foundation")]
2351 impl ::std::default::Default for STATPROPSTG {
default() -> Self2352     fn default() -> Self {
2353         unsafe { ::std::mem::zeroed() }
2354     }
2355 }
2356 #[cfg(feature = "Win32_Foundation")]
2357 impl ::std::fmt::Debug for STATPROPSTG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2358     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2359         fmt.debug_struct("STATPROPSTG").field("lpwstrName", &self.lpwstrName).field("propid", &self.propid).field("vt", &self.vt).finish()
2360     }
2361 }
2362 #[cfg(feature = "Win32_Foundation")]
2363 impl ::std::cmp::PartialEq for STATPROPSTG {
eq(&self, other: &Self) -> bool2364     fn eq(&self, other: &Self) -> bool {
2365         self.lpwstrName == other.lpwstrName && self.propid == other.propid && self.vt == other.vt
2366     }
2367 }
2368 #[cfg(feature = "Win32_Foundation")]
2369 impl ::std::cmp::Eq for STATPROPSTG {}
2370 #[cfg(feature = "Win32_Foundation")]
2371 unsafe impl ::windows::runtime::Abi for STATPROPSTG {
2372     type Abi = Self;
2373     type DefaultType = Self;
2374 }
2375 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2376 #[repr(transparent)]
2377 pub struct STGC(pub i32);
2378 pub const STGC_DEFAULT: STGC = STGC(0i32);
2379 pub const STGC_OVERWRITE: STGC = STGC(1i32);
2380 pub const STGC_ONLYIFCURRENT: STGC = STGC(2i32);
2381 pub const STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE: STGC = STGC(4i32);
2382 pub const STGC_CONSOLIDATE: STGC = STGC(8i32);
2383 impl ::std::convert::From<i32> for STGC {
from(value: i32) -> Self2384     fn from(value: i32) -> Self {
2385         Self(value)
2386     }
2387 }
2388 unsafe impl ::windows::runtime::Abi for STGC {
2389     type Abi = Self;
2390     type DefaultType = Self;
2391 }
2392 pub const STGFMT_ANY: u32 = 4u32;
2393 pub const STGFMT_DOCFILE: u32 = 5u32;
2394 pub const STGFMT_DOCUMENT: u32 = 0u32;
2395 pub const STGFMT_FILE: u32 = 3u32;
2396 pub const STGFMT_NATIVE: u32 = 1u32;
2397 pub const STGFMT_STORAGE: u32 = 0u32;
2398 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2399 #[repr(transparent)]
2400 pub struct STGMOVE(pub i32);
2401 pub const STGMOVE_MOVE: STGMOVE = STGMOVE(0i32);
2402 pub const STGMOVE_COPY: STGMOVE = STGMOVE(1i32);
2403 pub const STGMOVE_SHALLOWCOPY: STGMOVE = STGMOVE(2i32);
2404 impl ::std::convert::From<i32> for STGMOVE {
from(value: i32) -> Self2405     fn from(value: i32) -> Self {
2406         Self(value)
2407     }
2408 }
2409 unsafe impl ::windows::runtime::Abi for STGMOVE {
2410     type Abi = Self;
2411     type DefaultType = Self;
2412 }
2413 pub const STGM_CONVERT: i32 = 131072i32;
2414 pub const STGM_CREATE: i32 = 4096i32;
2415 pub const STGM_DELETEONRELEASE: i32 = 67108864i32;
2416 pub const STGM_DIRECT: i32 = 0i32;
2417 pub const STGM_DIRECT_SWMR: i32 = 4194304i32;
2418 pub const STGM_FAILIFTHERE: i32 = 0i32;
2419 pub const STGM_NOSCRATCH: i32 = 1048576i32;
2420 pub const STGM_NOSNAPSHOT: i32 = 2097152i32;
2421 pub const STGM_PRIORITY: i32 = 262144i32;
2422 pub const STGM_READ: i32 = 0i32;
2423 pub const STGM_READWRITE: i32 = 2i32;
2424 pub const STGM_SHARE_DENY_NONE: i32 = 64i32;
2425 pub const STGM_SHARE_DENY_READ: i32 = 48i32;
2426 pub const STGM_SHARE_DENY_WRITE: i32 = 32i32;
2427 pub const STGM_SHARE_EXCLUSIVE: i32 = 16i32;
2428 pub const STGM_SIMPLE: i32 = 134217728i32;
2429 pub const STGM_TRANSACTED: i32 = 65536i32;
2430 pub const STGM_WRITE: i32 = 1i32;
2431 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2432 #[repr(C)]
2433 #[cfg(feature = "Win32_Foundation")]
2434 pub struct STGOPTIONS {
2435     pub usVersion: u16,
2436     pub reserved: u16,
2437     pub ulSectorSize: u32,
2438     pub pwcsTemplateFile: super::super::super::Foundation::PWSTR,
2439 }
2440 #[cfg(feature = "Win32_Foundation")]
2441 impl STGOPTIONS {}
2442 #[cfg(feature = "Win32_Foundation")]
2443 impl ::std::default::Default for STGOPTIONS {
default() -> Self2444     fn default() -> Self {
2445         unsafe { ::std::mem::zeroed() }
2446     }
2447 }
2448 #[cfg(feature = "Win32_Foundation")]
2449 impl ::std::fmt::Debug for STGOPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2450     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2451         fmt.debug_struct("STGOPTIONS").field("usVersion", &self.usVersion).field("reserved", &self.reserved).field("ulSectorSize", &self.ulSectorSize).field("pwcsTemplateFile", &self.pwcsTemplateFile).finish()
2452     }
2453 }
2454 #[cfg(feature = "Win32_Foundation")]
2455 impl ::std::cmp::PartialEq for STGOPTIONS {
eq(&self, other: &Self) -> bool2456     fn eq(&self, other: &Self) -> bool {
2457         self.usVersion == other.usVersion && self.reserved == other.reserved && self.ulSectorSize == other.ulSectorSize && self.pwcsTemplateFile == other.pwcsTemplateFile
2458     }
2459 }
2460 #[cfg(feature = "Win32_Foundation")]
2461 impl ::std::cmp::Eq for STGOPTIONS {}
2462 #[cfg(feature = "Win32_Foundation")]
2463 unsafe impl ::windows::runtime::Abi for STGOPTIONS {
2464     type Abi = Self;
2465     type DefaultType = Self;
2466 }
2467 pub const STGOPTIONS_VERSION: u32 = 1u32;
2468 #[cfg(feature = "Win32_Foundation")]
2469 #[inline]
SetConvertStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(pstg: Param0, fconvert: Param1) -> ::windows::runtime::Result<()>2470 pub unsafe fn SetConvertStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(pstg: Param0, fconvert: Param1) -> ::windows::runtime::Result<()> {
2471     #[cfg(windows)]
2472     {
2473         #[link(name = "windows")]
2474         extern "system" {
2475             fn SetConvertStg(pstg: ::windows::runtime::RawPtr, fconvert: super::super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
2476         }
2477         SetConvertStg(pstg.into_param().abi(), fconvert.into_param().abi()).ok()
2478     }
2479     #[cfg(not(windows))]
2480     unimplemented!("Unsupported target OS");
2481 }
2482 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2483 #[inline]
StgConvertPropertyToVariant(pprop: *const SERIALIZEDPROPERTYVALUE, codepage: u16, pvar: *mut PROPVARIANT, pma: *const PMemoryAllocator) -> super::super::super::Foundation::BOOLEAN2484 pub unsafe fn StgConvertPropertyToVariant(pprop: *const SERIALIZEDPROPERTYVALUE, codepage: u16, pvar: *mut PROPVARIANT, pma: *const PMemoryAllocator) -> super::super::super::Foundation::BOOLEAN {
2485     #[cfg(windows)]
2486     {
2487         #[link(name = "windows")]
2488         extern "system" {
2489             fn StgConvertPropertyToVariant(pprop: *const SERIALIZEDPROPERTYVALUE, codepage: u16, pvar: *mut ::std::mem::ManuallyDrop<PROPVARIANT>, pma: *const PMemoryAllocator) -> super::super::super::Foundation::BOOLEAN;
2490         }
2491         ::std::mem::transmute(StgConvertPropertyToVariant(::std::mem::transmute(pprop), ::std::mem::transmute(codepage), ::std::mem::transmute(pvar), ::std::mem::transmute(pma)))
2492     }
2493     #[cfg(not(windows))]
2494     unimplemented!("Unsupported target OS");
2495 }
2496 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2497 #[inline]
StgConvertVariantToProperty<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(pvar: *const PROPVARIANT, codepage: u16, pprop: *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32, pid: u32, freserved: Param5, pcindirect: *mut u32) -> *mut SERIALIZEDPROPERTYVALUE2498 pub unsafe fn StgConvertVariantToProperty<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(pvar: *const PROPVARIANT, codepage: u16, pprop: *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32, pid: u32, freserved: Param5, pcindirect: *mut u32) -> *mut SERIALIZEDPROPERTYVALUE {
2499     #[cfg(windows)]
2500     {
2501         #[link(name = "windows")]
2502         extern "system" {
2503             fn StgConvertVariantToProperty(pvar: *const ::std::mem::ManuallyDrop<PROPVARIANT>, codepage: u16, pprop: *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32, pid: u32, freserved: super::super::super::Foundation::BOOLEAN, pcindirect: *mut u32) -> *mut SERIALIZEDPROPERTYVALUE;
2504         }
2505         ::std::mem::transmute(StgConvertVariantToProperty(::std::mem::transmute(pvar), ::std::mem::transmute(codepage), ::std::mem::transmute(pprop), ::std::mem::transmute(pcb), ::std::mem::transmute(pid), freserved.into_param().abi(), ::std::mem::transmute(pcindirect)))
2506     }
2507     #[cfg(not(windows))]
2508     unimplemented!("Unsupported target OS");
2509 }
2510 #[cfg(feature = "Win32_Foundation")]
2511 #[inline]
StgCreateDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage>2512 pub unsafe fn StgCreateDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage> {
2513     #[cfg(windows)]
2514     {
2515         #[link(name = "windows")]
2516         extern "system" {
2517             fn StgCreateDocfile(pwcsname: super::super::super::Foundation::PWSTR, grfmode: u32, reserved: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2518         }
2519         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2520         StgCreateDocfile(pwcsname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
2521     }
2522     #[cfg(not(windows))]
2523     unimplemented!("Unsupported target OS");
2524 }
2525 #[inline]
StgCreateDocfileOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage>2526 pub unsafe fn StgCreateDocfileOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage> {
2527     #[cfg(windows)]
2528     {
2529         #[link(name = "windows")]
2530         extern "system" {
2531             fn StgCreateDocfileOnILockBytes(plkbyt: ::windows::runtime::RawPtr, grfmode: u32, reserved: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2532         }
2533         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2534         StgCreateDocfileOnILockBytes(plkbyt.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
2535     }
2536     #[cfg(not(windows))]
2537     unimplemented!("Unsupported target OS");
2538 }
2539 #[inline]
StgCreatePropSetStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstorage: Param0, dwreserved: u32) -> ::windows::runtime::Result<IPropertySetStorage>2540 pub unsafe fn StgCreatePropSetStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstorage: Param0, dwreserved: u32) -> ::windows::runtime::Result<IPropertySetStorage> {
2541     #[cfg(windows)]
2542     {
2543         #[link(name = "windows")]
2544         extern "system" {
2545             fn StgCreatePropSetStg(pstorage: ::windows::runtime::RawPtr, dwreserved: u32, pppropsetstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2546         }
2547         let mut result__: <IPropertySetStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2548         StgCreatePropSetStg(pstorage.into_param().abi(), ::std::mem::transmute(dwreserved), &mut result__).from_abi::<IPropertySetStorage>(result__)
2549     }
2550     #[cfg(not(windows))]
2551     unimplemented!("Unsupported target OS");
2552 }
2553 #[inline]
StgCreatePropStg<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(punk: Param0, fmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32) -> ::windows::runtime::Result<IPropertyStorage>2554 pub unsafe fn StgCreatePropStg<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(punk: Param0, fmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32) -> ::windows::runtime::Result<IPropertyStorage> {
2555     #[cfg(windows)]
2556     {
2557         #[link(name = "windows")]
2558         extern "system" {
2559             fn StgCreatePropStg(punk: ::windows::runtime::RawPtr, fmtid: *const ::windows::runtime::GUID, pclsid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32, pppropstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2560         }
2561         let mut result__: <IPropertyStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2562         StgCreatePropStg(punk.into_param().abi(), ::std::mem::transmute(fmtid), ::std::mem::transmute(pclsid), ::std::mem::transmute(grfflags), ::std::mem::transmute(dwreserved), &mut result__).from_abi::<IPropertyStorage>(result__)
2563     }
2564     #[cfg(not(windows))]
2565     unimplemented!("Unsupported target OS");
2566 }
2567 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
2568 #[inline]
StgCreateStorageEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>2569 pub unsafe fn StgCreateStorageEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
2570     #[cfg(windows)]
2571     {
2572         #[link(name = "windows")]
2573         extern "system" {
2574             fn StgCreateStorageEx(pwcsname: super::super::super::Foundation::PWSTR, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
2575         }
2576         StgCreateStorageEx(pwcsname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(stgfmt), ::std::mem::transmute(grfattrs), ::std::mem::transmute(pstgoptions), ::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(riid), ::std::mem::transmute(ppobjectopen)).ok()
2577     }
2578     #[cfg(not(windows))]
2579     unimplemented!("Unsupported target OS");
2580 }
2581 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2582 #[inline]
StgDeserializePropVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbmax: u32) -> ::windows::runtime::Result<PROPVARIANT>2583 pub unsafe fn StgDeserializePropVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbmax: u32) -> ::windows::runtime::Result<PROPVARIANT> {
2584     #[cfg(windows)]
2585     {
2586         #[link(name = "windows")]
2587         extern "system" {
2588             fn StgDeserializePropVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbmax: u32, ppropvar: *mut ::std::mem::ManuallyDrop<PROPVARIANT>) -> ::windows::runtime::HRESULT;
2589         }
2590         let mut result__: <PROPVARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2591         StgDeserializePropVariant(::std::mem::transmute(pprop), ::std::mem::transmute(cbmax), &mut result__).from_abi::<PROPVARIANT>(result__)
2592     }
2593     #[cfg(not(windows))]
2594     unimplemented!("Unsupported target OS");
2595 }
2596 #[cfg(feature = "Win32_Foundation")]
2597 #[inline]
StgGetIFillLockBytesOnFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0) -> ::windows::runtime::Result<IFillLockBytes>2598 pub unsafe fn StgGetIFillLockBytesOnFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0) -> ::windows::runtime::Result<IFillLockBytes> {
2599     #[cfg(windows)]
2600     {
2601         #[link(name = "windows")]
2602         extern "system" {
2603             fn StgGetIFillLockBytesOnFile(pwcsname: super::super::super::Foundation::PWSTR, ppflb: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2604         }
2605         let mut result__: <IFillLockBytes as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2606         StgGetIFillLockBytesOnFile(pwcsname.into_param().abi(), &mut result__).from_abi::<IFillLockBytes>(result__)
2607     }
2608     #[cfg(not(windows))]
2609     unimplemented!("Unsupported target OS");
2610 }
2611 #[inline]
StgGetIFillLockBytesOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(pilb: Param0) -> ::windows::runtime::Result<IFillLockBytes>2612 pub unsafe fn StgGetIFillLockBytesOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(pilb: Param0) -> ::windows::runtime::Result<IFillLockBytes> {
2613     #[cfg(windows)]
2614     {
2615         #[link(name = "windows")]
2616         extern "system" {
2617             fn StgGetIFillLockBytesOnILockBytes(pilb: ::windows::runtime::RawPtr, ppflb: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2618         }
2619         let mut result__: <IFillLockBytes as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2620         StgGetIFillLockBytesOnILockBytes(pilb.into_param().abi(), &mut result__).from_abi::<IFillLockBytes>(result__)
2621     }
2622     #[cfg(not(windows))]
2623     unimplemented!("Unsupported target OS");
2624 }
2625 #[cfg(feature = "Win32_Foundation")]
2626 #[inline]
StgIsStorageFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0) -> ::windows::runtime::Result<()>2627 pub unsafe fn StgIsStorageFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0) -> ::windows::runtime::Result<()> {
2628     #[cfg(windows)]
2629     {
2630         #[link(name = "windows")]
2631         extern "system" {
2632             fn StgIsStorageFile(pwcsname: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
2633         }
2634         StgIsStorageFile(pwcsname.into_param().abi()).ok()
2635     }
2636     #[cfg(not(windows))]
2637     unimplemented!("Unsupported target OS");
2638 }
2639 #[inline]
StgIsStorageILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0) -> ::windows::runtime::Result<()>2640 pub unsafe fn StgIsStorageILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>>(plkbyt: Param0) -> ::windows::runtime::Result<()> {
2641     #[cfg(windows)]
2642     {
2643         #[link(name = "windows")]
2644         extern "system" {
2645             fn StgIsStorageILockBytes(plkbyt: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2646         }
2647         StgIsStorageILockBytes(plkbyt.into_param().abi()).ok()
2648     }
2649     #[cfg(not(windows))]
2650     unimplemented!("Unsupported target OS");
2651 }
2652 #[inline]
StgOpenAsyncDocfileOnIFillLockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, IFillLockBytes>>(pflb: Param0, grfmode: u32, asyncflags: u32) -> ::windows::runtime::Result<IStorage>2653 pub unsafe fn StgOpenAsyncDocfileOnIFillLockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, IFillLockBytes>>(pflb: Param0, grfmode: u32, asyncflags: u32) -> ::windows::runtime::Result<IStorage> {
2654     #[cfg(windows)]
2655     {
2656         #[link(name = "windows")]
2657         extern "system" {
2658             fn StgOpenAsyncDocfileOnIFillLockBytes(pflb: ::windows::runtime::RawPtr, grfmode: u32, asyncflags: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2659         }
2660         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2661         StgOpenAsyncDocfileOnIFillLockBytes(pflb.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(asyncflags), &mut result__).from_abi::<IStorage>(result__)
2662     }
2663     #[cfg(not(windows))]
2664     unimplemented!("Unsupported target OS");
2665 }
2666 #[cfg(feature = "Win32_Foundation")]
2667 #[inline]
StgOpenLayoutDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsdfname: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage>2668 pub unsafe fn StgOpenLayoutDocfile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsdfname: Param0, grfmode: u32, reserved: u32) -> ::windows::runtime::Result<IStorage> {
2669     #[cfg(windows)]
2670     {
2671         #[link(name = "windows")]
2672         extern "system" {
2673             fn StgOpenLayoutDocfile(pwcsdfname: super::super::super::Foundation::PWSTR, grfmode: u32, reserved: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2674         }
2675         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2676         StgOpenLayoutDocfile(pwcsdfname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
2677     }
2678     #[cfg(not(windows))]
2679     unimplemented!("Unsupported target OS");
2680 }
2681 #[inline]
StgOpenPropStg<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(punk: Param0, fmtid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32) -> ::windows::runtime::Result<IPropertyStorage>2682 pub unsafe fn StgOpenPropStg<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(punk: Param0, fmtid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32) -> ::windows::runtime::Result<IPropertyStorage> {
2683     #[cfg(windows)]
2684     {
2685         #[link(name = "windows")]
2686         extern "system" {
2687             fn StgOpenPropStg(punk: ::windows::runtime::RawPtr, fmtid: *const ::windows::runtime::GUID, grfflags: u32, dwreserved: u32, pppropstg: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2688         }
2689         let mut result__: <IPropertyStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2690         StgOpenPropStg(punk.into_param().abi(), ::std::mem::transmute(fmtid), ::std::mem::transmute(grfflags), ::std::mem::transmute(dwreserved), &mut result__).from_abi::<IPropertyStorage>(result__)
2691     }
2692     #[cfg(not(windows))]
2693     unimplemented!("Unsupported target OS");
2694 }
2695 #[cfg(feature = "Win32_Foundation")]
2696 #[inline]
StgOpenStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(pwcsname: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage>2697 pub unsafe fn StgOpenStorage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(pwcsname: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage> {
2698     #[cfg(windows)]
2699     {
2700         #[link(name = "windows")]
2701         extern "system" {
2702             fn StgOpenStorage(pwcsname: super::super::super::Foundation::PWSTR, pstgpriority: ::windows::runtime::RawPtr, grfmode: u32, snbexclude: *const *const u16, reserved: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2703         }
2704         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2705         StgOpenStorage(pwcsname.into_param().abi(), pstgpriority.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(snbexclude), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
2706     }
2707     #[cfg(not(windows))]
2708     unimplemented!("Unsupported target OS");
2709 }
2710 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
2711 #[inline]
StgOpenStorageEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>2712 pub unsafe fn StgOpenStorageEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwcsname: Param0, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
2713     #[cfg(windows)]
2714     {
2715         #[link(name = "windows")]
2716         extern "system" {
2717             fn StgOpenStorageEx(pwcsname: super::super::super::Foundation::PWSTR, grfmode: u32, stgfmt: u32, grfattrs: u32, pstgoptions: *mut STGOPTIONS, psecuritydescriptor: *const super::super::super::Security::SECURITY_DESCRIPTOR, riid: *const ::windows::runtime::GUID, ppobjectopen: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
2718         }
2719         StgOpenStorageEx(pwcsname.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(stgfmt), ::std::mem::transmute(grfattrs), ::std::mem::transmute(pstgoptions), ::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(riid), ::std::mem::transmute(ppobjectopen)).ok()
2720     }
2721     #[cfg(not(windows))]
2722     unimplemented!("Unsupported target OS");
2723 }
2724 #[inline]
StgOpenStorageOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(plkbyt: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage>2725 pub unsafe fn StgOpenStorageOnILockBytes<'a, Param0: ::windows::runtime::IntoParam<'a, ILockBytes>, Param1: ::windows::runtime::IntoParam<'a, IStorage>>(plkbyt: Param0, pstgpriority: Param1, grfmode: u32, snbexclude: *const *const u16, reserved: u32) -> ::windows::runtime::Result<IStorage> {
2726     #[cfg(windows)]
2727     {
2728         #[link(name = "windows")]
2729         extern "system" {
2730             fn StgOpenStorageOnILockBytes(plkbyt: ::windows::runtime::RawPtr, pstgpriority: ::windows::runtime::RawPtr, grfmode: u32, snbexclude: *const *const u16, reserved: u32, ppstgopen: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
2731         }
2732         let mut result__: <IStorage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2733         StgOpenStorageOnILockBytes(plkbyt.into_param().abi(), pstgpriority.into_param().abi(), ::std::mem::transmute(grfmode), ::std::mem::transmute(snbexclude), ::std::mem::transmute(reserved), &mut result__).from_abi::<IStorage>(result__)
2734     }
2735     #[cfg(not(windows))]
2736     unimplemented!("Unsupported target OS");
2737 }
2738 #[inline]
StgPropertyLengthAsVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbprop: u32, codepage: u16, breserved: u8) -> u322739 pub unsafe fn StgPropertyLengthAsVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbprop: u32, codepage: u16, breserved: u8) -> u32 {
2740     #[cfg(windows)]
2741     {
2742         #[link(name = "windows")]
2743         extern "system" {
2744             fn StgPropertyLengthAsVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbprop: u32, codepage: u16, breserved: u8) -> u32;
2745         }
2746         ::std::mem::transmute(StgPropertyLengthAsVariant(::std::mem::transmute(pprop), ::std::mem::transmute(cbprop), ::std::mem::transmute(codepage), ::std::mem::transmute(breserved)))
2747     }
2748     #[cfg(not(windows))]
2749     unimplemented!("Unsupported target OS");
2750 }
2751 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole_Automation"))]
2752 #[inline]
StgSerializePropVariant(ppropvar: *const PROPVARIANT, ppprop: *mut *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32) -> ::windows::runtime::Result<()>2753 pub unsafe fn StgSerializePropVariant(ppropvar: *const PROPVARIANT, ppprop: *mut *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32) -> ::windows::runtime::Result<()> {
2754     #[cfg(windows)]
2755     {
2756         #[link(name = "windows")]
2757         extern "system" {
2758             fn StgSerializePropVariant(ppropvar: *const ::std::mem::ManuallyDrop<PROPVARIANT>, ppprop: *mut *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32) -> ::windows::runtime::HRESULT;
2759         }
2760         StgSerializePropVariant(::std::mem::transmute(ppropvar), ::std::mem::transmute(ppprop), ::std::mem::transmute(pcb)).ok()
2761     }
2762     #[cfg(not(windows))]
2763     unimplemented!("Unsupported target OS");
2764 }
2765 #[cfg(feature = "Win32_Foundation")]
2766 #[inline]
StgSetTimes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(lpszname: Param0, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()>2767 pub unsafe fn StgSetTimes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(lpszname: Param0, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::Result<()> {
2768     #[cfg(windows)]
2769     {
2770         #[link(name = "windows")]
2771         extern "system" {
2772             fn StgSetTimes(lpszname: super::super::super::Foundation::PWSTR, pctime: *const super::super::super::Foundation::FILETIME, patime: *const super::super::super::Foundation::FILETIME, pmtime: *const super::super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT;
2773         }
2774         StgSetTimes(lpszname.into_param().abi(), ::std::mem::transmute(pctime), ::std::mem::transmute(patime), ::std::mem::transmute(pmtime)).ok()
2775     }
2776     #[cfg(not(windows))]
2777     unimplemented!("Unsupported target OS");
2778 }
2779 #[derive(:: std :: clone :: Clone)]
2780 #[repr(C)]
2781 pub struct VERSIONEDSTREAM {
2782     pub guidVersion: ::windows::runtime::GUID,
2783     pub pStream: ::std::option::Option<super::IStream>,
2784 }
2785 impl VERSIONEDSTREAM {}
2786 impl ::std::default::Default for VERSIONEDSTREAM {
default() -> Self2787     fn default() -> Self {
2788         unsafe { ::std::mem::zeroed() }
2789     }
2790 }
2791 impl ::std::fmt::Debug for VERSIONEDSTREAM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2792     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2793         fmt.debug_struct("VERSIONEDSTREAM").field("guidVersion", &self.guidVersion).field("pStream", &self.pStream).finish()
2794     }
2795 }
2796 impl ::std::cmp::PartialEq for VERSIONEDSTREAM {
eq(&self, other: &Self) -> bool2797     fn eq(&self, other: &Self) -> bool {
2798         self.guidVersion == other.guidVersion && self.pStream == other.pStream
2799     }
2800 }
2801 impl ::std::cmp::Eq for VERSIONEDSTREAM {}
2802 unsafe impl ::windows::runtime::Abi for VERSIONEDSTREAM {
2803     type Abi = ::std::mem::ManuallyDrop<Self>;
2804     type DefaultType = Self;
2805 }
2806 #[inline]
WriteClassStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()>2807 pub unsafe fn WriteClassStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>>(pstg: Param0, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
2808     #[cfg(windows)]
2809     {
2810         #[link(name = "windows")]
2811         extern "system" {
2812             fn WriteClassStg(pstg: ::windows::runtime::RawPtr, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
2813         }
2814         WriteClassStg(pstg.into_param().abi(), ::std::mem::transmute(rclsid)).ok()
2815     }
2816     #[cfg(not(windows))]
2817     unimplemented!("Unsupported target OS");
2818 }
2819 #[inline]
WriteClassStm<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()>2820 pub unsafe fn WriteClassStm<'a, Param0: ::windows::runtime::IntoParam<'a, super::IStream>>(pstm: Param0, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
2821     #[cfg(windows)]
2822     {
2823         #[link(name = "windows")]
2824         extern "system" {
2825             fn WriteClassStm(pstm: ::windows::runtime::RawPtr, rclsid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
2826         }
2827         WriteClassStm(pstm.into_param().abi(), ::std::mem::transmute(rclsid)).ok()
2828     }
2829     #[cfg(not(windows))]
2830     unimplemented!("Unsupported target OS");
2831 }
2832 #[cfg(feature = "Win32_Foundation")]
2833 #[inline]
WriteFmtUserTypeStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pstg: Param0, cf: u16, lpszusertype: Param2) -> ::windows::runtime::Result<()>2834 pub unsafe fn WriteFmtUserTypeStg<'a, Param0: ::windows::runtime::IntoParam<'a, IStorage>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pstg: Param0, cf: u16, lpszusertype: Param2) -> ::windows::runtime::Result<()> {
2835     #[cfg(windows)]
2836     {
2837         #[link(name = "windows")]
2838         extern "system" {
2839             fn WriteFmtUserTypeStg(pstg: ::windows::runtime::RawPtr, cf: u16, lpszusertype: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
2840         }
2841         WriteFmtUserTypeStg(pstg.into_param().abi(), ::std::mem::transmute(cf), lpszusertype.into_param().abi()).ok()
2842     }
2843     #[cfg(not(windows))]
2844     unimplemented!("Unsupported target OS");
2845 }
2846