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 #[cfg(feature = "Win32_Foundation")]
5 pub struct ACTCTXA {
6     pub cbSize: u32,
7     pub dwFlags: u32,
8     pub lpSource: super::super::Foundation::PSTR,
9     pub wProcessorArchitecture: u16,
10     pub wLangId: u16,
11     pub lpAssemblyDirectory: super::super::Foundation::PSTR,
12     pub lpResourceName: super::super::Foundation::PSTR,
13     pub lpApplicationName: super::super::Foundation::PSTR,
14     pub hModule: super::super::Foundation::HINSTANCE,
15 }
16 #[cfg(feature = "Win32_Foundation")]
17 impl ACTCTXA {}
18 #[cfg(feature = "Win32_Foundation")]
19 impl ::std::default::Default for ACTCTXA {
default() -> Self20     fn default() -> Self {
21         unsafe { ::std::mem::zeroed() }
22     }
23 }
24 #[cfg(feature = "Win32_Foundation")]
25 impl ::std::fmt::Debug for ACTCTXA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27         fmt.debug_struct("ACTCTXA")
28             .field("cbSize", &self.cbSize)
29             .field("dwFlags", &self.dwFlags)
30             .field("lpSource", &self.lpSource)
31             .field("wProcessorArchitecture", &self.wProcessorArchitecture)
32             .field("wLangId", &self.wLangId)
33             .field("lpAssemblyDirectory", &self.lpAssemblyDirectory)
34             .field("lpResourceName", &self.lpResourceName)
35             .field("lpApplicationName", &self.lpApplicationName)
36             .field("hModule", &self.hModule)
37             .finish()
38     }
39 }
40 #[cfg(feature = "Win32_Foundation")]
41 impl ::std::cmp::PartialEq for ACTCTXA {
eq(&self, other: &Self) -> bool42     fn eq(&self, other: &Self) -> bool {
43         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.lpSource == other.lpSource && self.wProcessorArchitecture == other.wProcessorArchitecture && self.wLangId == other.wLangId && self.lpAssemblyDirectory == other.lpAssemblyDirectory && self.lpResourceName == other.lpResourceName && self.lpApplicationName == other.lpApplicationName && self.hModule == other.hModule
44     }
45 }
46 #[cfg(feature = "Win32_Foundation")]
47 impl ::std::cmp::Eq for ACTCTXA {}
48 #[cfg(feature = "Win32_Foundation")]
49 unsafe impl ::windows::runtime::Abi for ACTCTXA {
50     type Abi = Self;
51     type DefaultType = Self;
52 }
53 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
54 #[repr(C)]
55 #[cfg(feature = "Win32_Foundation")]
56 pub struct ACTCTXW {
57     pub cbSize: u32,
58     pub dwFlags: u32,
59     pub lpSource: super::super::Foundation::PWSTR,
60     pub wProcessorArchitecture: u16,
61     pub wLangId: u16,
62     pub lpAssemblyDirectory: super::super::Foundation::PWSTR,
63     pub lpResourceName: super::super::Foundation::PWSTR,
64     pub lpApplicationName: super::super::Foundation::PWSTR,
65     pub hModule: super::super::Foundation::HINSTANCE,
66 }
67 #[cfg(feature = "Win32_Foundation")]
68 impl ACTCTXW {}
69 #[cfg(feature = "Win32_Foundation")]
70 impl ::std::default::Default for ACTCTXW {
default() -> Self71     fn default() -> Self {
72         unsafe { ::std::mem::zeroed() }
73     }
74 }
75 #[cfg(feature = "Win32_Foundation")]
76 impl ::std::fmt::Debug for ACTCTXW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result77     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
78         fmt.debug_struct("ACTCTXW")
79             .field("cbSize", &self.cbSize)
80             .field("dwFlags", &self.dwFlags)
81             .field("lpSource", &self.lpSource)
82             .field("wProcessorArchitecture", &self.wProcessorArchitecture)
83             .field("wLangId", &self.wLangId)
84             .field("lpAssemblyDirectory", &self.lpAssemblyDirectory)
85             .field("lpResourceName", &self.lpResourceName)
86             .field("lpApplicationName", &self.lpApplicationName)
87             .field("hModule", &self.hModule)
88             .finish()
89     }
90 }
91 #[cfg(feature = "Win32_Foundation")]
92 impl ::std::cmp::PartialEq for ACTCTXW {
eq(&self, other: &Self) -> bool93     fn eq(&self, other: &Self) -> bool {
94         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.lpSource == other.lpSource && self.wProcessorArchitecture == other.wProcessorArchitecture && self.wLangId == other.wLangId && self.lpAssemblyDirectory == other.lpAssemblyDirectory && self.lpResourceName == other.lpResourceName && self.lpApplicationName == other.lpApplicationName && self.hModule == other.hModule
95     }
96 }
97 #[cfg(feature = "Win32_Foundation")]
98 impl ::std::cmp::Eq for ACTCTXW {}
99 #[cfg(feature = "Win32_Foundation")]
100 unsafe impl ::windows::runtime::Abi for ACTCTXW {
101     type Abi = Self;
102     type DefaultType = Self;
103 }
104 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
105 #[repr(transparent)]
106 pub struct ACTCTX_COMPATIBILITY_ELEMENT_TYPE(pub i32);
107 pub const ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN: ACTCTX_COMPATIBILITY_ELEMENT_TYPE = ACTCTX_COMPATIBILITY_ELEMENT_TYPE(0i32);
108 pub const ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS: ACTCTX_COMPATIBILITY_ELEMENT_TYPE = ACTCTX_COMPATIBILITY_ELEMENT_TYPE(1i32);
109 pub const ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION: ACTCTX_COMPATIBILITY_ELEMENT_TYPE = ACTCTX_COMPATIBILITY_ELEMENT_TYPE(2i32);
110 pub const ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED: ACTCTX_COMPATIBILITY_ELEMENT_TYPE = ACTCTX_COMPATIBILITY_ELEMENT_TYPE(3i32);
111 impl ::std::convert::From<i32> for ACTCTX_COMPATIBILITY_ELEMENT_TYPE {
from(value: i32) -> Self112     fn from(value: i32) -> Self {
113         Self(value)
114     }
115 }
116 unsafe impl ::windows::runtime::Abi for ACTCTX_COMPATIBILITY_ELEMENT_TYPE {
117     type Abi = Self;
118     type DefaultType = Self;
119 }
120 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
121 #[repr(transparent)]
122 pub struct ACTCTX_REQUESTED_RUN_LEVEL(pub i32);
123 pub const ACTCTX_RUN_LEVEL_UNSPECIFIED: ACTCTX_REQUESTED_RUN_LEVEL = ACTCTX_REQUESTED_RUN_LEVEL(0i32);
124 pub const ACTCTX_RUN_LEVEL_AS_INVOKER: ACTCTX_REQUESTED_RUN_LEVEL = ACTCTX_REQUESTED_RUN_LEVEL(1i32);
125 pub const ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE: ACTCTX_REQUESTED_RUN_LEVEL = ACTCTX_REQUESTED_RUN_LEVEL(2i32);
126 pub const ACTCTX_RUN_LEVEL_REQUIRE_ADMIN: ACTCTX_REQUESTED_RUN_LEVEL = ACTCTX_REQUESTED_RUN_LEVEL(3i32);
127 pub const ACTCTX_RUN_LEVEL_NUMBERS: ACTCTX_REQUESTED_RUN_LEVEL = ACTCTX_REQUESTED_RUN_LEVEL(4i32);
128 impl ::std::convert::From<i32> for ACTCTX_REQUESTED_RUN_LEVEL {
from(value: i32) -> Self129     fn from(value: i32) -> Self {
130         Self(value)
131     }
132 }
133 unsafe impl ::windows::runtime::Abi for ACTCTX_REQUESTED_RUN_LEVEL {
134     type Abi = Self;
135     type DefaultType = Self;
136 }
137 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
138 #[repr(C)]
139 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
140 pub struct ACTCTX_SECTION_KEYED_DATA {
141     pub cbSize: u32,
142     pub ulDataFormatVersion: u32,
143     pub lpData: *mut ::std::ffi::c_void,
144     pub ulLength: u32,
145     pub lpSectionGlobalData: *mut ::std::ffi::c_void,
146     pub ulSectionGlobalDataLength: u32,
147     pub lpSectionBase: *mut ::std::ffi::c_void,
148     pub ulSectionTotalLength: u32,
149     pub hActCtx: super::super::Foundation::HANDLE,
150     pub ulAssemblyRosterIndex: u32,
151     pub ulFlags: u32,
152     pub AssemblyMetadata: super::WindowsProgramming::ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
153 }
154 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
155 impl ACTCTX_SECTION_KEYED_DATA {}
156 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
157 impl ::std::default::Default for ACTCTX_SECTION_KEYED_DATA {
default() -> Self158     fn default() -> Self {
159         unsafe { ::std::mem::zeroed() }
160     }
161 }
162 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
163 impl ::std::fmt::Debug for ACTCTX_SECTION_KEYED_DATA {
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("ACTCTX_SECTION_KEYED_DATA")
166             .field("cbSize", &self.cbSize)
167             .field("ulDataFormatVersion", &self.ulDataFormatVersion)
168             .field("lpData", &self.lpData)
169             .field("ulLength", &self.ulLength)
170             .field("lpSectionGlobalData", &self.lpSectionGlobalData)
171             .field("ulSectionGlobalDataLength", &self.ulSectionGlobalDataLength)
172             .field("lpSectionBase", &self.lpSectionBase)
173             .field("ulSectionTotalLength", &self.ulSectionTotalLength)
174             .field("hActCtx", &self.hActCtx)
175             .field("ulAssemblyRosterIndex", &self.ulAssemblyRosterIndex)
176             .field("ulFlags", &self.ulFlags)
177             .field("AssemblyMetadata", &self.AssemblyMetadata)
178             .finish()
179     }
180 }
181 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
182 impl ::std::cmp::PartialEq for ACTCTX_SECTION_KEYED_DATA {
eq(&self, other: &Self) -> bool183     fn eq(&self, other: &Self) -> bool {
184         self.cbSize == other.cbSize
185             && self.ulDataFormatVersion == other.ulDataFormatVersion
186             && self.lpData == other.lpData
187             && self.ulLength == other.ulLength
188             && self.lpSectionGlobalData == other.lpSectionGlobalData
189             && self.ulSectionGlobalDataLength == other.ulSectionGlobalDataLength
190             && self.lpSectionBase == other.lpSectionBase
191             && self.ulSectionTotalLength == other.ulSectionTotalLength
192             && self.hActCtx == other.hActCtx
193             && self.ulAssemblyRosterIndex == other.ulAssemblyRosterIndex
194             && self.ulFlags == other.ulFlags
195             && self.AssemblyMetadata == other.AssemblyMetadata
196     }
197 }
198 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
199 impl ::std::cmp::Eq for ACTCTX_SECTION_KEYED_DATA {}
200 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
201 unsafe impl ::windows::runtime::Abi for ACTCTX_SECTION_KEYED_DATA {
202     type Abi = Self;
203     type DefaultType = Self;
204 }
205 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
206 #[repr(C)]
207 #[cfg(feature = "Win32_Foundation")]
208 pub struct ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
209     pub ulFlags: u32,
210     pub ulEncodedAssemblyIdentityLength: u32,
211     pub ulManifestPathType: u32,
212     pub ulManifestPathLength: u32,
213     pub liManifestLastWriteTime: i64,
214     pub ulPolicyPathType: u32,
215     pub ulPolicyPathLength: u32,
216     pub liPolicyLastWriteTime: i64,
217     pub ulMetadataSatelliteRosterIndex: u32,
218     pub ulManifestVersionMajor: u32,
219     pub ulManifestVersionMinor: u32,
220     pub ulPolicyVersionMajor: u32,
221     pub ulPolicyVersionMinor: u32,
222     pub ulAssemblyDirectoryNameLength: u32,
223     pub lpAssemblyEncodedAssemblyIdentity: super::super::Foundation::PWSTR,
224     pub lpAssemblyManifestPath: super::super::Foundation::PWSTR,
225     pub lpAssemblyPolicyPath: super::super::Foundation::PWSTR,
226     pub lpAssemblyDirectoryName: super::super::Foundation::PWSTR,
227     pub ulFileCount: u32,
228 }
229 #[cfg(feature = "Win32_Foundation")]
230 impl ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {}
231 #[cfg(feature = "Win32_Foundation")]
232 impl ::std::default::Default for ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
default() -> Self233     fn default() -> Self {
234         unsafe { ::std::mem::zeroed() }
235     }
236 }
237 #[cfg(feature = "Win32_Foundation")]
238 impl ::std::fmt::Debug for ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result239     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
240         fmt.debug_struct("ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION")
241             .field("ulFlags", &self.ulFlags)
242             .field("ulEncodedAssemblyIdentityLength", &self.ulEncodedAssemblyIdentityLength)
243             .field("ulManifestPathType", &self.ulManifestPathType)
244             .field("ulManifestPathLength", &self.ulManifestPathLength)
245             .field("liManifestLastWriteTime", &self.liManifestLastWriteTime)
246             .field("ulPolicyPathType", &self.ulPolicyPathType)
247             .field("ulPolicyPathLength", &self.ulPolicyPathLength)
248             .field("liPolicyLastWriteTime", &self.liPolicyLastWriteTime)
249             .field("ulMetadataSatelliteRosterIndex", &self.ulMetadataSatelliteRosterIndex)
250             .field("ulManifestVersionMajor", &self.ulManifestVersionMajor)
251             .field("ulManifestVersionMinor", &self.ulManifestVersionMinor)
252             .field("ulPolicyVersionMajor", &self.ulPolicyVersionMajor)
253             .field("ulPolicyVersionMinor", &self.ulPolicyVersionMinor)
254             .field("ulAssemblyDirectoryNameLength", &self.ulAssemblyDirectoryNameLength)
255             .field("lpAssemblyEncodedAssemblyIdentity", &self.lpAssemblyEncodedAssemblyIdentity)
256             .field("lpAssemblyManifestPath", &self.lpAssemblyManifestPath)
257             .field("lpAssemblyPolicyPath", &self.lpAssemblyPolicyPath)
258             .field("lpAssemblyDirectoryName", &self.lpAssemblyDirectoryName)
259             .field("ulFileCount", &self.ulFileCount)
260             .finish()
261     }
262 }
263 #[cfg(feature = "Win32_Foundation")]
264 impl ::std::cmp::PartialEq for ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
eq(&self, other: &Self) -> bool265     fn eq(&self, other: &Self) -> bool {
266         self.ulFlags == other.ulFlags
267             && self.ulEncodedAssemblyIdentityLength == other.ulEncodedAssemblyIdentityLength
268             && self.ulManifestPathType == other.ulManifestPathType
269             && self.ulManifestPathLength == other.ulManifestPathLength
270             && self.liManifestLastWriteTime == other.liManifestLastWriteTime
271             && self.ulPolicyPathType == other.ulPolicyPathType
272             && self.ulPolicyPathLength == other.ulPolicyPathLength
273             && self.liPolicyLastWriteTime == other.liPolicyLastWriteTime
274             && self.ulMetadataSatelliteRosterIndex == other.ulMetadataSatelliteRosterIndex
275             && self.ulManifestVersionMajor == other.ulManifestVersionMajor
276             && self.ulManifestVersionMinor == other.ulManifestVersionMinor
277             && self.ulPolicyVersionMajor == other.ulPolicyVersionMajor
278             && self.ulPolicyVersionMinor == other.ulPolicyVersionMinor
279             && self.ulAssemblyDirectoryNameLength == other.ulAssemblyDirectoryNameLength
280             && self.lpAssemblyEncodedAssemblyIdentity == other.lpAssemblyEncodedAssemblyIdentity
281             && self.lpAssemblyManifestPath == other.lpAssemblyManifestPath
282             && self.lpAssemblyPolicyPath == other.lpAssemblyPolicyPath
283             && self.lpAssemblyDirectoryName == other.lpAssemblyDirectoryName
284             && self.ulFileCount == other.ulFileCount
285     }
286 }
287 #[cfg(feature = "Win32_Foundation")]
288 impl ::std::cmp::Eq for ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {}
289 #[cfg(feature = "Win32_Foundation")]
290 unsafe impl ::windows::runtime::Abi for ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION {
291     type Abi = Self;
292     type DefaultType = Self;
293 }
294 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
295 #[repr(C)]
296 pub struct ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
297     pub ElementCount: u32,
298     pub Elements: [COMPATIBILITY_CONTEXT_ELEMENT; 1],
299 }
300 impl ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {}
301 impl ::std::default::Default for ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
default() -> Self302     fn default() -> Self {
303         unsafe { ::std::mem::zeroed() }
304     }
305 }
306 impl ::std::fmt::Debug for ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result307     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
308         fmt.debug_struct("ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION").field("ElementCount", &self.ElementCount).field("Elements", &self.Elements).finish()
309     }
310 }
311 impl ::std::cmp::PartialEq for ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
eq(&self, other: &Self) -> bool312     fn eq(&self, other: &Self) -> bool {
313         self.ElementCount == other.ElementCount && self.Elements == other.Elements
314     }
315 }
316 impl ::std::cmp::Eq for ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {}
317 unsafe impl ::windows::runtime::Abi for ACTIVATION_CONTEXT_COMPATIBILITY_INFORMATION {
318     type Abi = Self;
319     type DefaultType = Self;
320 }
321 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
322 #[repr(C)]
323 #[cfg(feature = "Win32_Foundation")]
324 pub struct ACTIVATION_CONTEXT_DETAILED_INFORMATION {
325     pub dwFlags: u32,
326     pub ulFormatVersion: u32,
327     pub ulAssemblyCount: u32,
328     pub ulRootManifestPathType: u32,
329     pub ulRootManifestPathChars: u32,
330     pub ulRootConfigurationPathType: u32,
331     pub ulRootConfigurationPathChars: u32,
332     pub ulAppDirPathType: u32,
333     pub ulAppDirPathChars: u32,
334     pub lpRootManifestPath: super::super::Foundation::PWSTR,
335     pub lpRootConfigurationPath: super::super::Foundation::PWSTR,
336     pub lpAppDirPath: super::super::Foundation::PWSTR,
337 }
338 #[cfg(feature = "Win32_Foundation")]
339 impl ACTIVATION_CONTEXT_DETAILED_INFORMATION {}
340 #[cfg(feature = "Win32_Foundation")]
341 impl ::std::default::Default for ACTIVATION_CONTEXT_DETAILED_INFORMATION {
default() -> Self342     fn default() -> Self {
343         unsafe { ::std::mem::zeroed() }
344     }
345 }
346 #[cfg(feature = "Win32_Foundation")]
347 impl ::std::fmt::Debug for ACTIVATION_CONTEXT_DETAILED_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result348     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
349         fmt.debug_struct("ACTIVATION_CONTEXT_DETAILED_INFORMATION")
350             .field("dwFlags", &self.dwFlags)
351             .field("ulFormatVersion", &self.ulFormatVersion)
352             .field("ulAssemblyCount", &self.ulAssemblyCount)
353             .field("ulRootManifestPathType", &self.ulRootManifestPathType)
354             .field("ulRootManifestPathChars", &self.ulRootManifestPathChars)
355             .field("ulRootConfigurationPathType", &self.ulRootConfigurationPathType)
356             .field("ulRootConfigurationPathChars", &self.ulRootConfigurationPathChars)
357             .field("ulAppDirPathType", &self.ulAppDirPathType)
358             .field("ulAppDirPathChars", &self.ulAppDirPathChars)
359             .field("lpRootManifestPath", &self.lpRootManifestPath)
360             .field("lpRootConfigurationPath", &self.lpRootConfigurationPath)
361             .field("lpAppDirPath", &self.lpAppDirPath)
362             .finish()
363     }
364 }
365 #[cfg(feature = "Win32_Foundation")]
366 impl ::std::cmp::PartialEq for ACTIVATION_CONTEXT_DETAILED_INFORMATION {
eq(&self, other: &Self) -> bool367     fn eq(&self, other: &Self) -> bool {
368         self.dwFlags == other.dwFlags
369             && self.ulFormatVersion == other.ulFormatVersion
370             && self.ulAssemblyCount == other.ulAssemblyCount
371             && self.ulRootManifestPathType == other.ulRootManifestPathType
372             && self.ulRootManifestPathChars == other.ulRootManifestPathChars
373             && self.ulRootConfigurationPathType == other.ulRootConfigurationPathType
374             && self.ulRootConfigurationPathChars == other.ulRootConfigurationPathChars
375             && self.ulAppDirPathType == other.ulAppDirPathType
376             && self.ulAppDirPathChars == other.ulAppDirPathChars
377             && self.lpRootManifestPath == other.lpRootManifestPath
378             && self.lpRootConfigurationPath == other.lpRootConfigurationPath
379             && self.lpAppDirPath == other.lpAppDirPath
380     }
381 }
382 #[cfg(feature = "Win32_Foundation")]
383 impl ::std::cmp::Eq for ACTIVATION_CONTEXT_DETAILED_INFORMATION {}
384 #[cfg(feature = "Win32_Foundation")]
385 unsafe impl ::windows::runtime::Abi for ACTIVATION_CONTEXT_DETAILED_INFORMATION {
386     type Abi = Self;
387     type DefaultType = Self;
388 }
389 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
390 #[repr(C)]
391 pub struct ACTIVATION_CONTEXT_QUERY_INDEX {
392     pub ulAssemblyIndex: u32,
393     pub ulFileIndexInAssembly: u32,
394 }
395 impl ACTIVATION_CONTEXT_QUERY_INDEX {}
396 impl ::std::default::Default for ACTIVATION_CONTEXT_QUERY_INDEX {
default() -> Self397     fn default() -> Self {
398         unsafe { ::std::mem::zeroed() }
399     }
400 }
401 impl ::std::fmt::Debug for ACTIVATION_CONTEXT_QUERY_INDEX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result402     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
403         fmt.debug_struct("ACTIVATION_CONTEXT_QUERY_INDEX").field("ulAssemblyIndex", &self.ulAssemblyIndex).field("ulFileIndexInAssembly", &self.ulFileIndexInAssembly).finish()
404     }
405 }
406 impl ::std::cmp::PartialEq for ACTIVATION_CONTEXT_QUERY_INDEX {
eq(&self, other: &Self) -> bool407     fn eq(&self, other: &Self) -> bool {
408         self.ulAssemblyIndex == other.ulAssemblyIndex && self.ulFileIndexInAssembly == other.ulFileIndexInAssembly
409     }
410 }
411 impl ::std::cmp::Eq for ACTIVATION_CONTEXT_QUERY_INDEX {}
412 unsafe impl ::windows::runtime::Abi for ACTIVATION_CONTEXT_QUERY_INDEX {
413     type Abi = Self;
414     type DefaultType = Self;
415 }
416 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
417 #[repr(C)]
418 pub struct ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
419     pub ulFlags: u32,
420     pub RunLevel: ACTCTX_REQUESTED_RUN_LEVEL,
421     pub UiAccess: u32,
422 }
423 impl ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {}
424 impl ::std::default::Default for ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
default() -> Self425     fn default() -> Self {
426         unsafe { ::std::mem::zeroed() }
427     }
428 }
429 impl ::std::fmt::Debug for ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result430     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
431         fmt.debug_struct("ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION").field("ulFlags", &self.ulFlags).field("RunLevel", &self.RunLevel).field("UiAccess", &self.UiAccess).finish()
432     }
433 }
434 impl ::std::cmp::PartialEq for ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
eq(&self, other: &Self) -> bool435     fn eq(&self, other: &Self) -> bool {
436         self.ulFlags == other.ulFlags && self.RunLevel == other.RunLevel && self.UiAccess == other.UiAccess
437     }
438 }
439 impl ::std::cmp::Eq for ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {}
440 unsafe impl ::windows::runtime::Abi for ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION {
441     type Abi = Self;
442     type DefaultType = Self;
443 }
444 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
445 #[repr(transparent)]
446 pub struct ADVERTISEFLAGS(pub i32);
447 pub const ADVERTISEFLAGS_MACHINEASSIGN: ADVERTISEFLAGS = ADVERTISEFLAGS(0i32);
448 pub const ADVERTISEFLAGS_USERASSIGN: ADVERTISEFLAGS = ADVERTISEFLAGS(1i32);
449 impl ::std::convert::From<i32> for ADVERTISEFLAGS {
from(value: i32) -> Self450     fn from(value: i32) -> Self {
451         Self(value)
452     }
453 }
454 unsafe impl ::windows::runtime::Abi for ADVERTISEFLAGS {
455     type Abi = Self;
456     type DefaultType = Self;
457 }
458 pub const APPLY_OPTION_FAIL_IF_CLOSE: u32 = 2u32;
459 pub const APPLY_OPTION_FAIL_IF_EXACT: u32 = 1u32;
460 pub const APPLY_OPTION_TEST_ONLY: u32 = 4u32;
461 pub const APPLY_OPTION_VALID_FLAGS: u32 = 7u32;
462 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
463 #[repr(transparent)]
464 pub struct ASM_BIND_FLAGS(pub u32);
465 pub const ASM_BINDF_FORCE_CACHE_INSTALL: ASM_BIND_FLAGS = ASM_BIND_FLAGS(1u32);
466 pub const ASM_BINDF_RFS_INTEGRITY_CHECK: ASM_BIND_FLAGS = ASM_BIND_FLAGS(2u32);
467 pub const ASM_BINDF_RFS_MODULE_CHECK: ASM_BIND_FLAGS = ASM_BIND_FLAGS(4u32);
468 pub const ASM_BINDF_BINPATH_PROBE_ONLY: ASM_BIND_FLAGS = ASM_BIND_FLAGS(8u32);
469 pub const ASM_BINDF_SHARED_BINPATH_HINT: ASM_BIND_FLAGS = ASM_BIND_FLAGS(16u32);
470 pub const ASM_BINDF_PARENT_ASM_HINT: ASM_BIND_FLAGS = ASM_BIND_FLAGS(32u32);
471 impl ::std::convert::From<u32> for ASM_BIND_FLAGS {
from(value: u32) -> Self472     fn from(value: u32) -> Self {
473         Self(value)
474     }
475 }
476 unsafe impl ::windows::runtime::Abi for ASM_BIND_FLAGS {
477     type Abi = Self;
478     type DefaultType = Self;
479 }
480 impl ::std::ops::BitOr for ASM_BIND_FLAGS {
481     type Output = Self;
bitor(self, rhs: Self) -> Self482     fn bitor(self, rhs: Self) -> Self {
483         Self(self.0 | rhs.0)
484     }
485 }
486 impl ::std::ops::BitAnd for ASM_BIND_FLAGS {
487     type Output = Self;
bitand(self, rhs: Self) -> Self488     fn bitand(self, rhs: Self) -> Self {
489         Self(self.0 & rhs.0)
490     }
491 }
492 impl ::std::ops::BitOrAssign for ASM_BIND_FLAGS {
bitor_assign(&mut self, rhs: Self)493     fn bitor_assign(&mut self, rhs: Self) {
494         self.0.bitor_assign(rhs.0)
495     }
496 }
497 impl ::std::ops::BitAndAssign for ASM_BIND_FLAGS {
bitand_assign(&mut self, rhs: Self)498     fn bitand_assign(&mut self, rhs: Self) {
499         self.0.bitand_assign(rhs.0)
500     }
501 }
502 impl ::std::ops::Not for ASM_BIND_FLAGS {
503     type Output = Self;
not(self) -> Self504     fn not(self) -> Self {
505         Self(self.0.not())
506     }
507 }
508 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
509 #[repr(transparent)]
510 pub struct ASM_CMP_FLAGS(pub i32);
511 pub const ASM_CMPF_NAME: ASM_CMP_FLAGS = ASM_CMP_FLAGS(1i32);
512 pub const ASM_CMPF_MAJOR_VERSION: ASM_CMP_FLAGS = ASM_CMP_FLAGS(2i32);
513 pub const ASM_CMPF_MINOR_VERSION: ASM_CMP_FLAGS = ASM_CMP_FLAGS(4i32);
514 pub const ASM_CMPF_BUILD_NUMBER: ASM_CMP_FLAGS = ASM_CMP_FLAGS(8i32);
515 pub const ASM_CMPF_REVISION_NUMBER: ASM_CMP_FLAGS = ASM_CMP_FLAGS(16i32);
516 pub const ASM_CMPF_PUBLIC_KEY_TOKEN: ASM_CMP_FLAGS = ASM_CMP_FLAGS(32i32);
517 pub const ASM_CMPF_CULTURE: ASM_CMP_FLAGS = ASM_CMP_FLAGS(64i32);
518 pub const ASM_CMPF_CUSTOM: ASM_CMP_FLAGS = ASM_CMP_FLAGS(128i32);
519 pub const ASM_CMPF_ALL: ASM_CMP_FLAGS = ASM_CMP_FLAGS(255i32);
520 pub const ASM_CMPF_DEFAULT: ASM_CMP_FLAGS = ASM_CMP_FLAGS(256i32);
521 impl ::std::convert::From<i32> for ASM_CMP_FLAGS {
from(value: i32) -> Self522     fn from(value: i32) -> Self {
523         Self(value)
524     }
525 }
526 unsafe impl ::windows::runtime::Abi for ASM_CMP_FLAGS {
527     type Abi = Self;
528     type DefaultType = Self;
529 }
530 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
531 #[repr(transparent)]
532 pub struct ASM_DISPLAY_FLAGS(pub i32);
533 pub const ASM_DISPLAYF_VERSION: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(1i32);
534 pub const ASM_DISPLAYF_CULTURE: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(2i32);
535 pub const ASM_DISPLAYF_PUBLIC_KEY_TOKEN: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(4i32);
536 pub const ASM_DISPLAYF_PUBLIC_KEY: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(8i32);
537 pub const ASM_DISPLAYF_CUSTOM: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(16i32);
538 pub const ASM_DISPLAYF_PROCESSORARCHITECTURE: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(32i32);
539 pub const ASM_DISPLAYF_LANGUAGEID: ASM_DISPLAY_FLAGS = ASM_DISPLAY_FLAGS(64i32);
540 impl ::std::convert::From<i32> for ASM_DISPLAY_FLAGS {
from(value: i32) -> Self541     fn from(value: i32) -> Self {
542         Self(value)
543     }
544 }
545 unsafe impl ::windows::runtime::Abi for ASM_DISPLAY_FLAGS {
546     type Abi = Self;
547     type DefaultType = Self;
548 }
549 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
550 #[repr(transparent)]
551 pub struct ASM_NAME(pub i32);
552 pub const ASM_NAME_PUBLIC_KEY: ASM_NAME = ASM_NAME(0i32);
553 pub const ASM_NAME_PUBLIC_KEY_TOKEN: ASM_NAME = ASM_NAME(1i32);
554 pub const ASM_NAME_HASH_VALUE: ASM_NAME = ASM_NAME(2i32);
555 pub const ASM_NAME_NAME: ASM_NAME = ASM_NAME(3i32);
556 pub const ASM_NAME_MAJOR_VERSION: ASM_NAME = ASM_NAME(4i32);
557 pub const ASM_NAME_MINOR_VERSION: ASM_NAME = ASM_NAME(5i32);
558 pub const ASM_NAME_BUILD_NUMBER: ASM_NAME = ASM_NAME(6i32);
559 pub const ASM_NAME_REVISION_NUMBER: ASM_NAME = ASM_NAME(7i32);
560 pub const ASM_NAME_CULTURE: ASM_NAME = ASM_NAME(8i32);
561 pub const ASM_NAME_PROCESSOR_ID_ARRAY: ASM_NAME = ASM_NAME(9i32);
562 pub const ASM_NAME_OSINFO_ARRAY: ASM_NAME = ASM_NAME(10i32);
563 pub const ASM_NAME_HASH_ALGID: ASM_NAME = ASM_NAME(11i32);
564 pub const ASM_NAME_ALIAS: ASM_NAME = ASM_NAME(12i32);
565 pub const ASM_NAME_CODEBASE_URL: ASM_NAME = ASM_NAME(13i32);
566 pub const ASM_NAME_CODEBASE_LASTMOD: ASM_NAME = ASM_NAME(14i32);
567 pub const ASM_NAME_NULL_PUBLIC_KEY: ASM_NAME = ASM_NAME(15i32);
568 pub const ASM_NAME_NULL_PUBLIC_KEY_TOKEN: ASM_NAME = ASM_NAME(16i32);
569 pub const ASM_NAME_CUSTOM: ASM_NAME = ASM_NAME(17i32);
570 pub const ASM_NAME_NULL_CUSTOM: ASM_NAME = ASM_NAME(18i32);
571 pub const ASM_NAME_MVID: ASM_NAME = ASM_NAME(19i32);
572 pub const ASM_NAME_MAX_PARAMS: ASM_NAME = ASM_NAME(20i32);
573 impl ::std::convert::From<i32> for ASM_NAME {
from(value: i32) -> Self574     fn from(value: i32) -> Self {
575         Self(value)
576     }
577 }
578 unsafe impl ::windows::runtime::Abi for ASM_NAME {
579     type Abi = Self;
580     type DefaultType = Self;
581 }
582 pub const ASSEMBLYINFO_FLAG_INSTALLED: u32 = 1u32;
583 pub const ASSEMBLYINFO_FLAG_PAYLOADRESIDENT: u32 = 2u32;
584 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
585 #[repr(C)]
586 #[cfg(feature = "Win32_Foundation")]
587 pub struct ASSEMBLY_FILE_DETAILED_INFORMATION {
588     pub ulFlags: u32,
589     pub ulFilenameLength: u32,
590     pub ulPathLength: u32,
591     pub lpFileName: super::super::Foundation::PWSTR,
592     pub lpFilePath: super::super::Foundation::PWSTR,
593 }
594 #[cfg(feature = "Win32_Foundation")]
595 impl ASSEMBLY_FILE_DETAILED_INFORMATION {}
596 #[cfg(feature = "Win32_Foundation")]
597 impl ::std::default::Default for ASSEMBLY_FILE_DETAILED_INFORMATION {
default() -> Self598     fn default() -> Self {
599         unsafe { ::std::mem::zeroed() }
600     }
601 }
602 #[cfg(feature = "Win32_Foundation")]
603 impl ::std::fmt::Debug for ASSEMBLY_FILE_DETAILED_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result604     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
605         fmt.debug_struct("ASSEMBLY_FILE_DETAILED_INFORMATION").field("ulFlags", &self.ulFlags).field("ulFilenameLength", &self.ulFilenameLength).field("ulPathLength", &self.ulPathLength).field("lpFileName", &self.lpFileName).field("lpFilePath", &self.lpFilePath).finish()
606     }
607 }
608 #[cfg(feature = "Win32_Foundation")]
609 impl ::std::cmp::PartialEq for ASSEMBLY_FILE_DETAILED_INFORMATION {
eq(&self, other: &Self) -> bool610     fn eq(&self, other: &Self) -> bool {
611         self.ulFlags == other.ulFlags && self.ulFilenameLength == other.ulFilenameLength && self.ulPathLength == other.ulPathLength && self.lpFileName == other.lpFileName && self.lpFilePath == other.lpFilePath
612     }
613 }
614 #[cfg(feature = "Win32_Foundation")]
615 impl ::std::cmp::Eq for ASSEMBLY_FILE_DETAILED_INFORMATION {}
616 #[cfg(feature = "Win32_Foundation")]
617 unsafe impl ::windows::runtime::Abi for ASSEMBLY_FILE_DETAILED_INFORMATION {
618     type Abi = Self;
619     type DefaultType = Self;
620 }
621 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
622 #[repr(C)]
623 #[cfg(feature = "Win32_Foundation")]
624 pub struct ASSEMBLY_INFO {
625     pub cbAssemblyInfo: u32,
626     pub dwAssemblyFlags: u32,
627     pub uliAssemblySizeInKB: u64,
628     pub pszCurrentAssemblyPathBuf: super::super::Foundation::PWSTR,
629     pub cchBuf: u32,
630 }
631 #[cfg(feature = "Win32_Foundation")]
632 impl ASSEMBLY_INFO {}
633 #[cfg(feature = "Win32_Foundation")]
634 impl ::std::default::Default for ASSEMBLY_INFO {
default() -> Self635     fn default() -> Self {
636         unsafe { ::std::mem::zeroed() }
637     }
638 }
639 #[cfg(feature = "Win32_Foundation")]
640 impl ::std::fmt::Debug for ASSEMBLY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result641     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
642         fmt.debug_struct("ASSEMBLY_INFO").field("cbAssemblyInfo", &self.cbAssemblyInfo).field("dwAssemblyFlags", &self.dwAssemblyFlags).field("uliAssemblySizeInKB", &self.uliAssemblySizeInKB).field("pszCurrentAssemblyPathBuf", &self.pszCurrentAssemblyPathBuf).field("cchBuf", &self.cchBuf).finish()
643     }
644 }
645 #[cfg(feature = "Win32_Foundation")]
646 impl ::std::cmp::PartialEq for ASSEMBLY_INFO {
eq(&self, other: &Self) -> bool647     fn eq(&self, other: &Self) -> bool {
648         self.cbAssemblyInfo == other.cbAssemblyInfo && self.dwAssemblyFlags == other.dwAssemblyFlags && self.uliAssemblySizeInKB == other.uliAssemblySizeInKB && self.pszCurrentAssemblyPathBuf == other.pszCurrentAssemblyPathBuf && self.cchBuf == other.cchBuf
649     }
650 }
651 #[cfg(feature = "Win32_Foundation")]
652 impl ::std::cmp::Eq for ASSEMBLY_INFO {}
653 #[cfg(feature = "Win32_Foundation")]
654 unsafe impl ::windows::runtime::Abi for ASSEMBLY_INFO {
655     type Abi = Self;
656     type DefaultType = Self;
657 }
658 #[cfg(feature = "Win32_Foundation")]
659 #[inline]
ActivateActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0, lpcookie: *mut usize) -> super::super::Foundation::BOOL660 pub unsafe fn ActivateActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0, lpcookie: *mut usize) -> super::super::Foundation::BOOL {
661     #[cfg(windows)]
662     {
663         #[link(name = "windows")]
664         extern "system" {
665             fn ActivateActCtx(hactctx: super::super::Foundation::HANDLE, lpcookie: *mut usize) -> super::super::Foundation::BOOL;
666         }
667         ::std::mem::transmute(ActivateActCtx(hactctx.into_param().abi(), ::std::mem::transmute(lpcookie)))
668     }
669     #[cfg(not(windows))]
670     unimplemented!("Unsupported target OS");
671 }
672 #[cfg(feature = "Win32_Foundation")]
673 #[inline]
AddRefActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0)674 pub unsafe fn AddRefActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0) {
675     #[cfg(windows)]
676     {
677         #[link(name = "windows")]
678         extern "system" {
679             fn AddRefActCtx(hactctx: super::super::Foundation::HANDLE);
680         }
681         ::std::mem::transmute(AddRefActCtx(hactctx.into_param().abi()))
682     }
683     #[cfg(not(windows))]
684     unimplemented!("Unsupported target OS");
685 }
686 #[cfg(feature = "Win32_Foundation")]
687 #[inline]
ApplyDeltaA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(applyflags: i64, lpsourcename: Param1, lpdeltaname: Param2, lptargetname: Param3) -> super::super::Foundation::BOOL688 pub unsafe fn ApplyDeltaA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(applyflags: i64, lpsourcename: Param1, lpdeltaname: Param2, lptargetname: Param3) -> super::super::Foundation::BOOL {
689     #[cfg(windows)]
690     {
691         #[link(name = "windows")]
692         extern "system" {
693             fn ApplyDeltaA(applyflags: i64, lpsourcename: super::super::Foundation::PSTR, lpdeltaname: super::super::Foundation::PSTR, lptargetname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
694         }
695         ::std::mem::transmute(ApplyDeltaA(::std::mem::transmute(applyflags), lpsourcename.into_param().abi(), lpdeltaname.into_param().abi(), lptargetname.into_param().abi()))
696     }
697     #[cfg(not(windows))]
698     unimplemented!("Unsupported target OS");
699 }
700 #[cfg(feature = "Win32_Foundation")]
701 #[inline]
ApplyDeltaB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lptarget: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL702 pub unsafe fn ApplyDeltaB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lptarget: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL {
703     #[cfg(windows)]
704     {
705         #[link(name = "windows")]
706         extern "system" {
707             fn ApplyDeltaB(applyflags: i64, source: DELTA_INPUT, delta: DELTA_INPUT, lptarget: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL;
708         }
709         ::std::mem::transmute(ApplyDeltaB(::std::mem::transmute(applyflags), source.into_param().abi(), delta.into_param().abi(), ::std::mem::transmute(lptarget)))
710     }
711     #[cfg(not(windows))]
712     unimplemented!("Unsupported target OS");
713 }
714 #[cfg(feature = "Win32_Foundation")]
715 #[inline]
ApplyDeltaGetReverseB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lpreversefiletime: *const super::super::Foundation::FILETIME, lptarget: *mut DELTA_OUTPUT, lptargetreverse: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL716 pub unsafe fn ApplyDeltaGetReverseB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lpreversefiletime: *const super::super::Foundation::FILETIME, lptarget: *mut DELTA_OUTPUT, lptargetreverse: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL {
717     #[cfg(windows)]
718     {
719         #[link(name = "windows")]
720         extern "system" {
721             fn ApplyDeltaGetReverseB(applyflags: i64, source: DELTA_INPUT, delta: DELTA_INPUT, lpreversefiletime: *const super::super::Foundation::FILETIME, lptarget: *mut DELTA_OUTPUT, lptargetreverse: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL;
722         }
723         ::std::mem::transmute(ApplyDeltaGetReverseB(::std::mem::transmute(applyflags), source.into_param().abi(), delta.into_param().abi(), ::std::mem::transmute(lpreversefiletime), ::std::mem::transmute(lptarget), ::std::mem::transmute(lptargetreverse)))
724     }
725     #[cfg(not(windows))]
726     unimplemented!("Unsupported target OS");
727 }
728 #[cfg(feature = "Win32_Foundation")]
729 #[inline]
ApplyDeltaProvidedB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lptarget: *mut ::std::ffi::c_void, utargetsize: usize) -> super::super::Foundation::BOOL730 pub unsafe fn ApplyDeltaProvidedB<'a, Param1: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(applyflags: i64, source: Param1, delta: Param2, lptarget: *mut ::std::ffi::c_void, utargetsize: usize) -> super::super::Foundation::BOOL {
731     #[cfg(windows)]
732     {
733         #[link(name = "windows")]
734         extern "system" {
735             fn ApplyDeltaProvidedB(applyflags: i64, source: DELTA_INPUT, delta: DELTA_INPUT, lptarget: *mut ::std::ffi::c_void, utargetsize: usize) -> super::super::Foundation::BOOL;
736         }
737         ::std::mem::transmute(ApplyDeltaProvidedB(::std::mem::transmute(applyflags), source.into_param().abi(), delta.into_param().abi(), ::std::mem::transmute(lptarget), ::std::mem::transmute(utargetsize)))
738     }
739     #[cfg(not(windows))]
740     unimplemented!("Unsupported target OS");
741 }
742 #[cfg(feature = "Win32_Foundation")]
743 #[inline]
ApplyDeltaW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(applyflags: i64, lpsourcename: Param1, lpdeltaname: Param2, lptargetname: Param3) -> super::super::Foundation::BOOL744 pub unsafe fn ApplyDeltaW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(applyflags: i64, lpsourcename: Param1, lpdeltaname: Param2, lptargetname: Param3) -> super::super::Foundation::BOOL {
745     #[cfg(windows)]
746     {
747         #[link(name = "windows")]
748         extern "system" {
749             fn ApplyDeltaW(applyflags: i64, lpsourcename: super::super::Foundation::PWSTR, lpdeltaname: super::super::Foundation::PWSTR, lptargetname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
750         }
751         ::std::mem::transmute(ApplyDeltaW(::std::mem::transmute(applyflags), lpsourcename.into_param().abi(), lpdeltaname.into_param().abi(), lptargetname.into_param().abi()))
752     }
753     #[cfg(not(windows))]
754     unimplemented!("Unsupported target OS");
755 }
756 #[cfg(feature = "Win32_Foundation")]
757 #[inline]
ApplyPatchToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL758 pub unsafe fn ApplyPatchToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL {
759     #[cfg(windows)]
760     {
761         #[link(name = "windows")]
762         extern "system" {
763             fn ApplyPatchToFileA(patchfilename: super::super::Foundation::PSTR, oldfilename: super::super::Foundation::PSTR, newfilename: super::super::Foundation::PSTR, applyoptionflags: u32) -> super::super::Foundation::BOOL;
764         }
765         ::std::mem::transmute(ApplyPatchToFileA(patchfilename.into_param().abi(), oldfilename.into_param().abi(), newfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
766     }
767     #[cfg(not(windows))]
768     unimplemented!("Unsupported target OS");
769 }
770 #[cfg(feature = "Win32_Foundation")]
771 #[inline]
ApplyPatchToFileByBuffers(patchfilemapped: *const u8, patchfilesize: u32, oldfilemapped: *const u8, oldfilesize: u32, newfilebuffer: *mut *mut u8, newfilebuffersize: u32, newfileactualsize: *mut u32, newfiletime: *mut super::super::Foundation::FILETIME, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL772 pub unsafe fn ApplyPatchToFileByBuffers(patchfilemapped: *const u8, patchfilesize: u32, oldfilemapped: *const u8, oldfilesize: u32, newfilebuffer: *mut *mut u8, newfilebuffersize: u32, newfileactualsize: *mut u32, newfiletime: *mut super::super::Foundation::FILETIME, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
773     #[cfg(windows)]
774     {
775         #[link(name = "windows")]
776         extern "system" {
777             fn ApplyPatchToFileByBuffers(patchfilemapped: *const u8, patchfilesize: u32, oldfilemapped: *const u8, oldfilesize: u32, newfilebuffer: *mut *mut u8, newfilebuffersize: u32, newfileactualsize: *mut u32, newfiletime: *mut super::super::Foundation::FILETIME, applyoptionflags: u32, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
778         }
779         ::std::mem::transmute(ApplyPatchToFileByBuffers(
780             ::std::mem::transmute(patchfilemapped),
781             ::std::mem::transmute(patchfilesize),
782             ::std::mem::transmute(oldfilemapped),
783             ::std::mem::transmute(oldfilesize),
784             ::std::mem::transmute(newfilebuffer),
785             ::std::mem::transmute(newfilebuffersize),
786             ::std::mem::transmute(newfileactualsize),
787             ::std::mem::transmute(newfiletime),
788             ::std::mem::transmute(applyoptionflags),
789             ::std::mem::transmute(progresscallback),
790             ::std::mem::transmute(callbackcontext),
791         ))
792     }
793     #[cfg(not(windows))]
794     unimplemented!("Unsupported target OS");
795 }
796 #[cfg(feature = "Win32_Foundation")]
797 #[inline]
ApplyPatchToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, oldfilehandle: Param1, newfilehandle: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL798 pub unsafe fn ApplyPatchToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, oldfilehandle: Param1, newfilehandle: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL {
799     #[cfg(windows)]
800     {
801         #[link(name = "windows")]
802         extern "system" {
803             fn ApplyPatchToFileByHandles(patchfilehandle: super::super::Foundation::HANDLE, oldfilehandle: super::super::Foundation::HANDLE, newfilehandle: super::super::Foundation::HANDLE, applyoptionflags: u32) -> super::super::Foundation::BOOL;
804         }
805         ::std::mem::transmute(ApplyPatchToFileByHandles(patchfilehandle.into_param().abi(), oldfilehandle.into_param().abi(), newfilehandle.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
806     }
807     #[cfg(not(windows))]
808     unimplemented!("Unsupported target OS");
809 }
810 #[cfg(feature = "Win32_Foundation")]
811 #[inline]
ApplyPatchToFileByHandlesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>( patchfilehandle: Param0, oldfilehandle: Param1, newfilehandle: Param2, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void, ) -> super::super::Foundation::BOOL812 pub unsafe fn ApplyPatchToFileByHandlesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(
813     patchfilehandle: Param0,
814     oldfilehandle: Param1,
815     newfilehandle: Param2,
816     applyoptionflags: u32,
817     progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>,
818     callbackcontext: *const ::std::ffi::c_void,
819 ) -> super::super::Foundation::BOOL {
820     #[cfg(windows)]
821     {
822         #[link(name = "windows")]
823         extern "system" {
824             fn ApplyPatchToFileByHandlesEx(patchfilehandle: super::super::Foundation::HANDLE, oldfilehandle: super::super::Foundation::HANDLE, newfilehandle: super::super::Foundation::HANDLE, applyoptionflags: u32, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
825         }
826         ::std::mem::transmute(ApplyPatchToFileByHandlesEx(patchfilehandle.into_param().abi(), oldfilehandle.into_param().abi(), newfilehandle.into_param().abi(), ::std::mem::transmute(applyoptionflags), ::std::mem::transmute(progresscallback), ::std::mem::transmute(callbackcontext)))
827     }
828     #[cfg(not(windows))]
829     unimplemented!("Unsupported target OS");
830 }
831 #[cfg(feature = "Win32_Foundation")]
832 #[inline]
ApplyPatchToFileExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL833 pub unsafe fn ApplyPatchToFileExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
834     #[cfg(windows)]
835     {
836         #[link(name = "windows")]
837         extern "system" {
838             fn ApplyPatchToFileExA(patchfilename: super::super::Foundation::PSTR, oldfilename: super::super::Foundation::PSTR, newfilename: super::super::Foundation::PSTR, applyoptionflags: u32, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
839         }
840         ::std::mem::transmute(ApplyPatchToFileExA(patchfilename.into_param().abi(), oldfilename.into_param().abi(), newfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags), ::std::mem::transmute(progresscallback), ::std::mem::transmute(callbackcontext)))
841     }
842     #[cfg(not(windows))]
843     unimplemented!("Unsupported target OS");
844 }
845 #[cfg(feature = "Win32_Foundation")]
846 #[inline]
ApplyPatchToFileExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL847 pub unsafe fn ApplyPatchToFileExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
848     #[cfg(windows)]
849     {
850         #[link(name = "windows")]
851         extern "system" {
852             fn ApplyPatchToFileExW(patchfilename: super::super::Foundation::PWSTR, oldfilename: super::super::Foundation::PWSTR, newfilename: super::super::Foundation::PWSTR, applyoptionflags: u32, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
853         }
854         ::std::mem::transmute(ApplyPatchToFileExW(patchfilename.into_param().abi(), oldfilename.into_param().abi(), newfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags), ::std::mem::transmute(progresscallback), ::std::mem::transmute(callbackcontext)))
855     }
856     #[cfg(not(windows))]
857     unimplemented!("Unsupported target OS");
858 }
859 #[cfg(feature = "Win32_Foundation")]
860 #[inline]
ApplyPatchToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL861 pub unsafe fn ApplyPatchToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, newfilename: Param2, applyoptionflags: u32) -> super::super::Foundation::BOOL {
862     #[cfg(windows)]
863     {
864         #[link(name = "windows")]
865         extern "system" {
866             fn ApplyPatchToFileW(patchfilename: super::super::Foundation::PWSTR, oldfilename: super::super::Foundation::PWSTR, newfilename: super::super::Foundation::PWSTR, applyoptionflags: u32) -> super::super::Foundation::BOOL;
867         }
868         ::std::mem::transmute(ApplyPatchToFileW(patchfilename.into_param().abi(), oldfilename.into_param().abi(), newfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
869     }
870     #[cfg(not(windows))]
871     unimplemented!("Unsupported target OS");
872 }
873 pub const CLSID_EvalCom2: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1851660560, 32851, 18016, [183, 149, 107, 97, 46, 41, 188, 88]);
874 pub const CLSID_MsmMerge2: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(4182345173, 10745, 18243, [152, 5, 153, 188, 63, 53, 182, 120]);
875 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
876 #[repr(C)]
877 pub struct COMPATIBILITY_CONTEXT_ELEMENT {
878     pub Id: ::windows::runtime::GUID,
879     pub Type: ACTCTX_COMPATIBILITY_ELEMENT_TYPE,
880     pub MaxVersionTested: u64,
881 }
882 impl COMPATIBILITY_CONTEXT_ELEMENT {}
883 impl ::std::default::Default for COMPATIBILITY_CONTEXT_ELEMENT {
default() -> Self884     fn default() -> Self {
885         unsafe { ::std::mem::zeroed() }
886     }
887 }
888 impl ::std::fmt::Debug for COMPATIBILITY_CONTEXT_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result889     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
890         fmt.debug_struct("COMPATIBILITY_CONTEXT_ELEMENT").field("Id", &self.Id).field("Type", &self.Type).field("MaxVersionTested", &self.MaxVersionTested).finish()
891     }
892 }
893 impl ::std::cmp::PartialEq for COMPATIBILITY_CONTEXT_ELEMENT {
eq(&self, other: &Self) -> bool894     fn eq(&self, other: &Self) -> bool {
895         self.Id == other.Id && self.Type == other.Type && self.MaxVersionTested == other.MaxVersionTested
896     }
897 }
898 impl ::std::cmp::Eq for COMPATIBILITY_CONTEXT_ELEMENT {}
899 unsafe impl ::windows::runtime::Abi for COMPATIBILITY_CONTEXT_ELEMENT {
900     type Abi = Self;
901     type DefaultType = Self;
902 }
903 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
904 #[repr(transparent)]
905 pub struct CREATE_ASM_NAME_OBJ_FLAGS(pub i32);
906 pub const CANOF_PARSE_DISPLAY_NAME: CREATE_ASM_NAME_OBJ_FLAGS = CREATE_ASM_NAME_OBJ_FLAGS(1i32);
907 pub const CANOF_SET_DEFAULT_VALUES: CREATE_ASM_NAME_OBJ_FLAGS = CREATE_ASM_NAME_OBJ_FLAGS(2i32);
908 impl ::std::convert::From<i32> for CREATE_ASM_NAME_OBJ_FLAGS {
from(value: i32) -> Self909     fn from(value: i32) -> Self {
910         Self(value)
911     }
912 }
913 unsafe impl ::windows::runtime::Abi for CREATE_ASM_NAME_OBJ_FLAGS {
914     type Abi = Self;
915     type DefaultType = Self;
916 }
917 #[cfg(feature = "Win32_Foundation")]
918 #[inline]
CreateActCtxA(pactctx: *const ACTCTXA) -> super::super::Foundation::HANDLE919 pub unsafe fn CreateActCtxA(pactctx: *const ACTCTXA) -> super::super::Foundation::HANDLE {
920     #[cfg(windows)]
921     {
922         #[link(name = "windows")]
923         extern "system" {
924             fn CreateActCtxA(pactctx: *const ACTCTXA) -> super::super::Foundation::HANDLE;
925         }
926         ::std::mem::transmute(CreateActCtxA(::std::mem::transmute(pactctx)))
927     }
928     #[cfg(not(windows))]
929     unimplemented!("Unsupported target OS");
930 }
931 #[cfg(feature = "Win32_Foundation")]
932 #[inline]
CreateActCtxW(pactctx: *const ACTCTXW) -> super::super::Foundation::HANDLE933 pub unsafe fn CreateActCtxW(pactctx: *const ACTCTXW) -> super::super::Foundation::HANDLE {
934     #[cfg(windows)]
935     {
936         #[link(name = "windows")]
937         extern "system" {
938             fn CreateActCtxW(pactctx: *const ACTCTXW) -> super::super::Foundation::HANDLE;
939         }
940         ::std::mem::transmute(CreateActCtxW(::std::mem::transmute(pactctx)))
941     }
942     #[cfg(not(windows))]
943     unimplemented!("Unsupported target OS");
944 }
945 #[cfg(feature = "Win32_Foundation")]
946 #[inline]
CreateDeltaA<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( filetypeset: i64, setflags: i64, resetflags: i64, lpsourcename: Param3, lptargetname: Param4, lpsourceoptionsname: Param5, lptargetoptionsname: Param6, globaloptions: Param7, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdeltaname: Param10, ) -> super::super::Foundation::BOOL947 pub unsafe fn CreateDeltaA<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
948     filetypeset: i64,
949     setflags: i64,
950     resetflags: i64,
951     lpsourcename: Param3,
952     lptargetname: Param4,
953     lpsourceoptionsname: Param5,
954     lptargetoptionsname: Param6,
955     globaloptions: Param7,
956     lptargetfiletime: *const super::super::Foundation::FILETIME,
957     hashalgid: u32,
958     lpdeltaname: Param10,
959 ) -> super::super::Foundation::BOOL {
960     #[cfg(windows)]
961     {
962         #[link(name = "windows")]
963         extern "system" {
964             fn CreateDeltaA(filetypeset: i64, setflags: i64, resetflags: i64, lpsourcename: super::super::Foundation::PSTR, lptargetname: super::super::Foundation::PSTR, lpsourceoptionsname: super::super::Foundation::PSTR, lptargetoptionsname: super::super::Foundation::PSTR, globaloptions: DELTA_INPUT, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdeltaname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
965         }
966         ::std::mem::transmute(CreateDeltaA(
967             ::std::mem::transmute(filetypeset),
968             ::std::mem::transmute(setflags),
969             ::std::mem::transmute(resetflags),
970             lpsourcename.into_param().abi(),
971             lptargetname.into_param().abi(),
972             lpsourceoptionsname.into_param().abi(),
973             lptargetoptionsname.into_param().abi(),
974             globaloptions.into_param().abi(),
975             ::std::mem::transmute(lptargetfiletime),
976             ::std::mem::transmute(hashalgid),
977             lpdeltaname.into_param().abi(),
978         ))
979     }
980     #[cfg(not(windows))]
981     unimplemented!("Unsupported target OS");
982 }
983 #[cfg(feature = "Win32_Foundation")]
984 #[inline]
CreateDeltaB<'a, Param3: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param4: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param5: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param6: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>( filetypeset: i64, setflags: i64, resetflags: i64, source: Param3, target: Param4, sourceoptions: Param5, targetoptions: Param6, globaloptions: Param7, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdelta: *mut DELTA_OUTPUT, ) -> super::super::Foundation::BOOL985 pub unsafe fn CreateDeltaB<'a, Param3: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param4: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param5: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param6: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(
986     filetypeset: i64,
987     setflags: i64,
988     resetflags: i64,
989     source: Param3,
990     target: Param4,
991     sourceoptions: Param5,
992     targetoptions: Param6,
993     globaloptions: Param7,
994     lptargetfiletime: *const super::super::Foundation::FILETIME,
995     hashalgid: u32,
996     lpdelta: *mut DELTA_OUTPUT,
997 ) -> super::super::Foundation::BOOL {
998     #[cfg(windows)]
999     {
1000         #[link(name = "windows")]
1001         extern "system" {
1002             fn CreateDeltaB(filetypeset: i64, setflags: i64, resetflags: i64, source: DELTA_INPUT, target: DELTA_INPUT, sourceoptions: DELTA_INPUT, targetoptions: DELTA_INPUT, globaloptions: DELTA_INPUT, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdelta: *mut DELTA_OUTPUT) -> super::super::Foundation::BOOL;
1003         }
1004         ::std::mem::transmute(CreateDeltaB(
1005             ::std::mem::transmute(filetypeset),
1006             ::std::mem::transmute(setflags),
1007             ::std::mem::transmute(resetflags),
1008             source.into_param().abi(),
1009             target.into_param().abi(),
1010             sourceoptions.into_param().abi(),
1011             targetoptions.into_param().abi(),
1012             globaloptions.into_param().abi(),
1013             ::std::mem::transmute(lptargetfiletime),
1014             ::std::mem::transmute(hashalgid),
1015             ::std::mem::transmute(lpdelta),
1016         ))
1017     }
1018     #[cfg(not(windows))]
1019     unimplemented!("Unsupported target OS");
1020 }
1021 #[cfg(feature = "Win32_Foundation")]
1022 #[inline]
CreateDeltaW<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( filetypeset: i64, setflags: i64, resetflags: i64, lpsourcename: Param3, lptargetname: Param4, lpsourceoptionsname: Param5, lptargetoptionsname: Param6, globaloptions: Param7, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdeltaname: Param10, ) -> super::super::Foundation::BOOL1023 pub unsafe fn CreateDeltaW<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, DELTA_INPUT>, Param10: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
1024     filetypeset: i64,
1025     setflags: i64,
1026     resetflags: i64,
1027     lpsourcename: Param3,
1028     lptargetname: Param4,
1029     lpsourceoptionsname: Param5,
1030     lptargetoptionsname: Param6,
1031     globaloptions: Param7,
1032     lptargetfiletime: *const super::super::Foundation::FILETIME,
1033     hashalgid: u32,
1034     lpdeltaname: Param10,
1035 ) -> super::super::Foundation::BOOL {
1036     #[cfg(windows)]
1037     {
1038         #[link(name = "windows")]
1039         extern "system" {
1040             fn CreateDeltaW(filetypeset: i64, setflags: i64, resetflags: i64, lpsourcename: super::super::Foundation::PWSTR, lptargetname: super::super::Foundation::PWSTR, lpsourceoptionsname: super::super::Foundation::PWSTR, lptargetoptionsname: super::super::Foundation::PWSTR, globaloptions: DELTA_INPUT, lptargetfiletime: *const super::super::Foundation::FILETIME, hashalgid: u32, lpdeltaname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1041         }
1042         ::std::mem::transmute(CreateDeltaW(
1043             ::std::mem::transmute(filetypeset),
1044             ::std::mem::transmute(setflags),
1045             ::std::mem::transmute(resetflags),
1046             lpsourcename.into_param().abi(),
1047             lptargetname.into_param().abi(),
1048             lpsourceoptionsname.into_param().abi(),
1049             lptargetoptionsname.into_param().abi(),
1050             globaloptions.into_param().abi(),
1051             ::std::mem::transmute(lptargetfiletime),
1052             ::std::mem::transmute(hashalgid),
1053             lpdeltaname.into_param().abi(),
1054         ))
1055     }
1056     #[cfg(not(windows))]
1057     unimplemented!("Unsupported target OS");
1058 }
1059 #[cfg(feature = "Win32_Foundation")]
1060 #[inline]
CreatePatchFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(oldfilename: Param0, newfilename: Param1, patchfilename: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL1061 pub unsafe fn CreatePatchFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(oldfilename: Param0, newfilename: Param1, patchfilename: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL {
1062     #[cfg(windows)]
1063     {
1064         #[link(name = "windows")]
1065         extern "system" {
1066             fn CreatePatchFileA(oldfilename: super::super::Foundation::PSTR, newfilename: super::super::Foundation::PSTR, patchfilename: super::super::Foundation::PSTR, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>) -> super::super::Foundation::BOOL;
1067         }
1068         ::std::mem::transmute(CreatePatchFileA(oldfilename.into_param().abi(), newfilename.into_param().abi(), patchfilename.into_param().abi(), ::std::mem::transmute(optionflags), ::std::mem::transmute(optiondata)))
1069     }
1070     #[cfg(not(windows))]
1071     unimplemented!("Unsupported target OS");
1072 }
1073 #[cfg(feature = "Win32_Foundation")]
1074 #[inline]
CreatePatchFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(oldfilehandle: Param0, newfilehandle: Param1, patchfilehandle: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL1075 pub unsafe fn CreatePatchFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(oldfilehandle: Param0, newfilehandle: Param1, patchfilehandle: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL {
1076     #[cfg(windows)]
1077     {
1078         #[link(name = "windows")]
1079         extern "system" {
1080             fn CreatePatchFileByHandles(oldfilehandle: super::super::Foundation::HANDLE, newfilehandle: super::super::Foundation::HANDLE, patchfilehandle: super::super::Foundation::HANDLE, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>) -> super::super::Foundation::BOOL;
1081         }
1082         ::std::mem::transmute(CreatePatchFileByHandles(oldfilehandle.into_param().abi(), newfilehandle.into_param().abi(), patchfilehandle.into_param().abi(), ::std::mem::transmute(optionflags), ::std::mem::transmute(optiondata)))
1083     }
1084     #[cfg(not(windows))]
1085     unimplemented!("Unsupported target OS");
1086 }
1087 #[cfg(feature = "Win32_Foundation")]
1088 #[inline]
CreatePatchFileByHandlesEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>( oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_H, newfilehandle: Param2, patchfilehandle: Param3, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void, ) -> super::super::Foundation::BOOL1089 pub unsafe fn CreatePatchFileByHandlesEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(
1090     oldfilecount: u32,
1091     oldfileinfoarray: *const PATCH_OLD_FILE_INFO_H,
1092     newfilehandle: Param2,
1093     patchfilehandle: Param3,
1094     optionflags: u32,
1095     optiondata: *const PATCH_OPTION_DATA,
1096     progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>,
1097     callbackcontext: *const ::std::ffi::c_void,
1098 ) -> super::super::Foundation::BOOL {
1099     #[cfg(windows)]
1100     {
1101         #[link(name = "windows")]
1102         extern "system" {
1103             fn CreatePatchFileByHandlesEx(oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_H, newfilehandle: super::super::Foundation::HANDLE, patchfilehandle: super::super::Foundation::HANDLE, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1104         }
1105         ::std::mem::transmute(CreatePatchFileByHandlesEx(
1106             ::std::mem::transmute(oldfilecount),
1107             ::std::mem::transmute(oldfileinfoarray),
1108             newfilehandle.into_param().abi(),
1109             patchfilehandle.into_param().abi(),
1110             ::std::mem::transmute(optionflags),
1111             ::std::mem::transmute(optiondata),
1112             ::std::mem::transmute(progresscallback),
1113             ::std::mem::transmute(callbackcontext),
1114         ))
1115     }
1116     #[cfg(not(windows))]
1117     unimplemented!("Unsupported target OS");
1118 }
1119 #[cfg(feature = "Win32_Foundation")]
1120 #[inline]
CreatePatchFileExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_A, newfilename: Param2, patchfilename: Param3, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL1121 pub unsafe fn CreatePatchFileExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_A, newfilename: Param2, patchfilename: Param3, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
1122     #[cfg(windows)]
1123     {
1124         #[link(name = "windows")]
1125         extern "system" {
1126             fn CreatePatchFileExA(oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_A, newfilename: super::super::Foundation::PSTR, patchfilename: super::super::Foundation::PSTR, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1127         }
1128         ::std::mem::transmute(CreatePatchFileExA(
1129             ::std::mem::transmute(oldfilecount),
1130             ::std::mem::transmute(oldfileinfoarray),
1131             newfilename.into_param().abi(),
1132             patchfilename.into_param().abi(),
1133             ::std::mem::transmute(optionflags),
1134             ::std::mem::transmute(optiondata),
1135             ::std::mem::transmute(progresscallback),
1136             ::std::mem::transmute(callbackcontext),
1137         ))
1138     }
1139     #[cfg(not(windows))]
1140     unimplemented!("Unsupported target OS");
1141 }
1142 #[cfg(feature = "Win32_Foundation")]
1143 #[inline]
CreatePatchFileExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_W, newfilename: Param2, patchfilename: Param3, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>, callbackcontext: *const ::std::ffi::c_void, ) -> super::super::Foundation::BOOL1144 pub unsafe fn CreatePatchFileExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
1145     oldfilecount: u32,
1146     oldfileinfoarray: *const PATCH_OLD_FILE_INFO_W,
1147     newfilename: Param2,
1148     patchfilename: Param3,
1149     optionflags: u32,
1150     optiondata: *const PATCH_OPTION_DATA,
1151     progresscallback: ::std::option::Option<PPATCH_PROGRESS_CALLBACK>,
1152     callbackcontext: *const ::std::ffi::c_void,
1153 ) -> super::super::Foundation::BOOL {
1154     #[cfg(windows)]
1155     {
1156         #[link(name = "windows")]
1157         extern "system" {
1158             fn CreatePatchFileExW(oldfilecount: u32, oldfileinfoarray: *const PATCH_OLD_FILE_INFO_W, newfilename: super::super::Foundation::PWSTR, patchfilename: super::super::Foundation::PWSTR, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>, progresscallback: ::windows::runtime::RawPtr, callbackcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1159         }
1160         ::std::mem::transmute(CreatePatchFileExW(
1161             ::std::mem::transmute(oldfilecount),
1162             ::std::mem::transmute(oldfileinfoarray),
1163             newfilename.into_param().abi(),
1164             patchfilename.into_param().abi(),
1165             ::std::mem::transmute(optionflags),
1166             ::std::mem::transmute(optiondata),
1167             ::std::mem::transmute(progresscallback),
1168             ::std::mem::transmute(callbackcontext),
1169         ))
1170     }
1171     #[cfg(not(windows))]
1172     unimplemented!("Unsupported target OS");
1173 }
1174 #[cfg(feature = "Win32_Foundation")]
1175 #[inline]
CreatePatchFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(oldfilename: Param0, newfilename: Param1, patchfilename: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL1176 pub unsafe fn CreatePatchFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(oldfilename: Param0, newfilename: Param1, patchfilename: Param2, optionflags: u32, optiondata: *const PATCH_OPTION_DATA) -> super::super::Foundation::BOOL {
1177     #[cfg(windows)]
1178     {
1179         #[link(name = "windows")]
1180         extern "system" {
1181             fn CreatePatchFileW(oldfilename: super::super::Foundation::PWSTR, newfilename: super::super::Foundation::PWSTR, patchfilename: super::super::Foundation::PWSTR, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>) -> super::super::Foundation::BOOL;
1182         }
1183         ::std::mem::transmute(CreatePatchFileW(oldfilename.into_param().abi(), newfilename.into_param().abi(), patchfilename.into_param().abi(), ::std::mem::transmute(optionflags), ::std::mem::transmute(optiondata)))
1184     }
1185     #[cfg(not(windows))]
1186     unimplemented!("Unsupported target OS");
1187 }
1188 pub const DEFAULT_DISK_ID: u32 = 2u32;
1189 pub const DEFAULT_FILE_SEQUENCE_START: u32 = 2u32;
1190 pub const DEFAULT_MINIMUM_REQUIRED_MSI_VERSION: u32 = 100u32;
1191 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1192 #[repr(C)]
1193 pub struct DELTA_HASH {
1194     pub HashSize: u32,
1195     pub HashValue: [u8; 32],
1196 }
1197 impl DELTA_HASH {}
1198 impl ::std::default::Default for DELTA_HASH {
default() -> Self1199     fn default() -> Self {
1200         unsafe { ::std::mem::zeroed() }
1201     }
1202 }
1203 impl ::std::fmt::Debug for DELTA_HASH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1204     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1205         fmt.debug_struct("DELTA_HASH").field("HashSize", &self.HashSize).field("HashValue", &self.HashValue).finish()
1206     }
1207 }
1208 impl ::std::cmp::PartialEq for DELTA_HASH {
eq(&self, other: &Self) -> bool1209     fn eq(&self, other: &Self) -> bool {
1210         self.HashSize == other.HashSize && self.HashValue == other.HashValue
1211     }
1212 }
1213 impl ::std::cmp::Eq for DELTA_HASH {}
1214 unsafe impl ::windows::runtime::Abi for DELTA_HASH {
1215     type Abi = Self;
1216     type DefaultType = Self;
1217 }
1218 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1219 #[repr(C)]
1220 #[cfg(feature = "Win32_Foundation")]
1221 pub struct DELTA_HEADER_INFO {
1222     pub FileTypeSet: i64,
1223     pub FileType: i64,
1224     pub Flags: i64,
1225     pub TargetSize: usize,
1226     pub TargetFileTime: super::super::Foundation::FILETIME,
1227     pub TargetHashAlgId: u32,
1228     pub TargetHash: DELTA_HASH,
1229 }
1230 #[cfg(feature = "Win32_Foundation")]
1231 impl DELTA_HEADER_INFO {}
1232 #[cfg(feature = "Win32_Foundation")]
1233 impl ::std::default::Default for DELTA_HEADER_INFO {
default() -> Self1234     fn default() -> Self {
1235         unsafe { ::std::mem::zeroed() }
1236     }
1237 }
1238 #[cfg(feature = "Win32_Foundation")]
1239 impl ::std::fmt::Debug for DELTA_HEADER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1240     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1241         fmt.debug_struct("DELTA_HEADER_INFO")
1242             .field("FileTypeSet", &self.FileTypeSet)
1243             .field("FileType", &self.FileType)
1244             .field("Flags", &self.Flags)
1245             .field("TargetSize", &self.TargetSize)
1246             .field("TargetFileTime", &self.TargetFileTime)
1247             .field("TargetHashAlgId", &self.TargetHashAlgId)
1248             .field("TargetHash", &self.TargetHash)
1249             .finish()
1250     }
1251 }
1252 #[cfg(feature = "Win32_Foundation")]
1253 impl ::std::cmp::PartialEq for DELTA_HEADER_INFO {
eq(&self, other: &Self) -> bool1254     fn eq(&self, other: &Self) -> bool {
1255         self.FileTypeSet == other.FileTypeSet && self.FileType == other.FileType && self.Flags == other.Flags && self.TargetSize == other.TargetSize && self.TargetFileTime == other.TargetFileTime && self.TargetHashAlgId == other.TargetHashAlgId && self.TargetHash == other.TargetHash
1256     }
1257 }
1258 #[cfg(feature = "Win32_Foundation")]
1259 impl ::std::cmp::Eq for DELTA_HEADER_INFO {}
1260 #[cfg(feature = "Win32_Foundation")]
1261 unsafe impl ::windows::runtime::Abi for DELTA_HEADER_INFO {
1262     type Abi = Self;
1263     type DefaultType = Self;
1264 }
1265 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1266 #[repr(C)]
1267 #[cfg(feature = "Win32_Foundation")]
1268 pub struct DELTA_INPUT {
1269     pub Anonymous: DELTA_INPUT_0,
1270     pub uSize: usize,
1271     pub Editable: super::super::Foundation::BOOL,
1272 }
1273 #[cfg(feature = "Win32_Foundation")]
1274 impl DELTA_INPUT {}
1275 #[cfg(feature = "Win32_Foundation")]
1276 impl ::std::default::Default for DELTA_INPUT {
default() -> Self1277     fn default() -> Self {
1278         unsafe { ::std::mem::zeroed() }
1279     }
1280 }
1281 #[cfg(feature = "Win32_Foundation")]
1282 impl ::std::cmp::PartialEq for DELTA_INPUT {
eq(&self, _other: &Self) -> bool1283     fn eq(&self, _other: &Self) -> bool {
1284         unimplemented!()
1285     }
1286 }
1287 #[cfg(feature = "Win32_Foundation")]
1288 impl ::std::cmp::Eq for DELTA_INPUT {}
1289 #[cfg(feature = "Win32_Foundation")]
1290 unsafe impl ::windows::runtime::Abi for DELTA_INPUT {
1291     type Abi = Self;
1292     type DefaultType = Self;
1293 }
1294 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1295 #[repr(C)]
1296 pub union DELTA_INPUT_0 {
1297     pub lpcStart: *mut ::std::ffi::c_void,
1298     pub lpStart: *mut ::std::ffi::c_void,
1299 }
1300 impl DELTA_INPUT_0 {}
1301 impl ::std::default::Default for DELTA_INPUT_0 {
default() -> Self1302     fn default() -> Self {
1303         unsafe { ::std::mem::zeroed() }
1304     }
1305 }
1306 impl ::std::cmp::PartialEq for DELTA_INPUT_0 {
eq(&self, _other: &Self) -> bool1307     fn eq(&self, _other: &Self) -> bool {
1308         unimplemented!()
1309     }
1310 }
1311 impl ::std::cmp::Eq for DELTA_INPUT_0 {}
1312 unsafe impl ::windows::runtime::Abi for DELTA_INPUT_0 {
1313     type Abi = Self;
1314     type DefaultType = Self;
1315 }
1316 pub const DELTA_MAX_HASH_SIZE: u32 = 32u32;
1317 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1318 #[repr(C)]
1319 pub struct DELTA_OUTPUT {
1320     pub lpStart: *mut ::std::ffi::c_void,
1321     pub uSize: usize,
1322 }
1323 impl DELTA_OUTPUT {}
1324 impl ::std::default::Default for DELTA_OUTPUT {
default() -> Self1325     fn default() -> Self {
1326         unsafe { ::std::mem::zeroed() }
1327     }
1328 }
1329 impl ::std::fmt::Debug for DELTA_OUTPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1330     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1331         fmt.debug_struct("DELTA_OUTPUT").field("lpStart", &self.lpStart).field("uSize", &self.uSize).finish()
1332     }
1333 }
1334 impl ::std::cmp::PartialEq for DELTA_OUTPUT {
eq(&self, other: &Self) -> bool1335     fn eq(&self, other: &Self) -> bool {
1336         self.lpStart == other.lpStart && self.uSize == other.uSize
1337     }
1338 }
1339 impl ::std::cmp::Eq for DELTA_OUTPUT {}
1340 unsafe impl ::windows::runtime::Abi for DELTA_OUTPUT {
1341     type Abi = Self;
1342     type DefaultType = Self;
1343 }
1344 #[cfg(feature = "Win32_Foundation")]
1345 #[inline]
DeactivateActCtx(dwflags: u32, ulcookie: usize) -> super::super::Foundation::BOOL1346 pub unsafe fn DeactivateActCtx(dwflags: u32, ulcookie: usize) -> super::super::Foundation::BOOL {
1347     #[cfg(windows)]
1348     {
1349         #[link(name = "windows")]
1350         extern "system" {
1351             fn DeactivateActCtx(dwflags: u32, ulcookie: usize) -> super::super::Foundation::BOOL;
1352         }
1353         ::std::mem::transmute(DeactivateActCtx(::std::mem::transmute(dwflags), ::std::mem::transmute(ulcookie)))
1354     }
1355     #[cfg(not(windows))]
1356     unimplemented!("Unsupported target OS");
1357 }
1358 #[cfg(feature = "Win32_Foundation")]
1359 #[inline]
DeltaFree(lpmemory: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL1360 pub unsafe fn DeltaFree(lpmemory: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
1361     #[cfg(windows)]
1362     {
1363         #[link(name = "windows")]
1364         extern "system" {
1365             fn DeltaFree(lpmemory: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
1366         }
1367         ::std::mem::transmute(DeltaFree(::std::mem::transmute(lpmemory)))
1368     }
1369     #[cfg(not(windows))]
1370     unimplemented!("Unsupported target OS");
1371 }
1372 #[cfg(feature = "Win32_Foundation")]
1373 #[inline]
DeltaNormalizeProvidedB<'a, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(filetypeset: i64, normalizeflags: i64, normalizeoptions: Param2, lpsource: *mut ::std::ffi::c_void, usourcesize: usize) -> super::super::Foundation::BOOL1374 pub unsafe fn DeltaNormalizeProvidedB<'a, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(filetypeset: i64, normalizeflags: i64, normalizeoptions: Param2, lpsource: *mut ::std::ffi::c_void, usourcesize: usize) -> super::super::Foundation::BOOL {
1375     #[cfg(windows)]
1376     {
1377         #[link(name = "windows")]
1378         extern "system" {
1379             fn DeltaNormalizeProvidedB(filetypeset: i64, normalizeflags: i64, normalizeoptions: DELTA_INPUT, lpsource: *mut ::std::ffi::c_void, usourcesize: usize) -> super::super::Foundation::BOOL;
1380         }
1381         ::std::mem::transmute(DeltaNormalizeProvidedB(::std::mem::transmute(filetypeset), ::std::mem::transmute(normalizeflags), normalizeoptions.into_param().abi(), ::std::mem::transmute(lpsource), ::std::mem::transmute(usourcesize)))
1382     }
1383     #[cfg(not(windows))]
1384     unimplemented!("Unsupported target OS");
1385 }
1386 pub const ERROR_PATCH_BIGGER_THAN_COMPRESSED: u32 = 3222155525u32;
1387 pub const ERROR_PATCH_CORRUPT: u32 = 3222159618u32;
1388 pub const ERROR_PATCH_DECODE_FAILURE: u32 = 3222159617u32;
1389 pub const ERROR_PATCH_ENCODE_FAILURE: u32 = 3222155521u32;
1390 pub const ERROR_PATCH_IMAGEHLP_FAILURE: u32 = 3222155526u32;
1391 pub const ERROR_PATCH_INVALID_OPTIONS: u32 = 3222155522u32;
1392 pub const ERROR_PATCH_NEWER_FORMAT: u32 = 3222159619u32;
1393 pub const ERROR_PATCH_NOT_AVAILABLE: u32 = 3222159622u32;
1394 pub const ERROR_PATCH_NOT_NECESSARY: u32 = 3222159621u32;
1395 pub const ERROR_PATCH_RETAIN_RANGES_DIFFER: u32 = 3222155524u32;
1396 pub const ERROR_PATCH_SAME_FILE: u32 = 3222155523u32;
1397 pub const ERROR_PATCH_WRONG_FILE: u32 = 3222159620u32;
1398 pub const ERROR_PCW_BAD_API_PATCHING_SYMBOL_FLAGS: u32 = 3222163725u32;
1399 pub const ERROR_PCW_BAD_FAMILY_RANGE_NAME: u32 = 3222163801u32;
1400 pub const ERROR_PCW_BAD_FILE_SEQUENCE_START: u32 = 3222163770u32;
1401 pub const ERROR_PCW_BAD_GUIDS_TO_REPLACE: u32 = 3222163721u32;
1402 pub const ERROR_PCW_BAD_IMAGE_FAMILY_DISKID: u32 = 3222163773u32;
1403 pub const ERROR_PCW_BAD_IMAGE_FAMILY_FILESEQSTART: u32 = 3222163774u32;
1404 pub const ERROR_PCW_BAD_IMAGE_FAMILY_NAME: u32 = 3222163748u32;
1405 pub const ERROR_PCW_BAD_IMAGE_FAMILY_SRC_PROP: u32 = 3222163750u32;
1406 pub const ERROR_PCW_BAD_MAJOR_VERSION: u32 = 3222163853u32;
1407 pub const ERROR_PCW_BAD_PATCH_GUID: u32 = 3222163720u32;
1408 pub const ERROR_PCW_BAD_PRODUCTVERSION_VALIDATION: u32 = 3222163844u32;
1409 pub const ERROR_PCW_BAD_SEQUENCE: u32 = 3222163848u32;
1410 pub const ERROR_PCW_BAD_SUPERCEDENCE: u32 = 3222163847u32;
1411 pub const ERROR_PCW_BAD_TARGET: u32 = 3222163849u32;
1412 pub const ERROR_PCW_BAD_TARGET_IMAGE_NAME: u32 = 3222163736u32;
1413 pub const ERROR_PCW_BAD_TARGET_IMAGE_PRODUCT_CODE: u32 = 3222163834u32;
1414 pub const ERROR_PCW_BAD_TARGET_IMAGE_PRODUCT_VERSION: u32 = 3222163835u32;
1415 pub const ERROR_PCW_BAD_TARGET_IMAGE_UPGRADED: u32 = 3222163776u32;
1416 pub const ERROR_PCW_BAD_TARGET_IMAGE_UPGRADE_CODE: u32 = 3222163836u32;
1417 pub const ERROR_PCW_BAD_TARGET_PRODUCT_CODE_LIST: u32 = 3222163722u32;
1418 pub const ERROR_PCW_BAD_TGT_UPD_IMAGES: u32 = 3222163846u32;
1419 pub const ERROR_PCW_BAD_TRANSFORMSET: u32 = 3222163845u32;
1420 pub const ERROR_PCW_BAD_UPGRADED_IMAGE_FAMILY: u32 = 3222163775u32;
1421 pub const ERROR_PCW_BAD_UPGRADED_IMAGE_NAME: u32 = 3222163728u32;
1422 pub const ERROR_PCW_BAD_UPGRADED_IMAGE_PRODUCT_CODE: u32 = 3222163831u32;
1423 pub const ERROR_PCW_BAD_UPGRADED_IMAGE_PRODUCT_VERSION: u32 = 3222163832u32;
1424 pub const ERROR_PCW_BAD_UPGRADED_IMAGE_UPGRADE_CODE: u32 = 3222163833u32;
1425 pub const ERROR_PCW_BAD_VERSION_STRING: u32 = 3222163852u32;
1426 pub const ERROR_PCW_BASE: u32 = 3222163713u32;
1427 pub const ERROR_PCW_CANNOT_CREATE_TABLE: u32 = 3222163841u32;
1428 pub const ERROR_PCW_CANNOT_RUN_MAKECAB: u32 = 3222163782u32;
1429 pub const ERROR_PCW_CANNOT_WRITE_DDF: u32 = 3222163781u32;
1430 pub const ERROR_PCW_CANT_COPY_FILE_TO_TEMP_FOLDER: u32 = 3222163771u32;
1431 pub const ERROR_PCW_CANT_CREATE_ONE_PATCH_FILE: u32 = 3222163772u32;
1432 pub const ERROR_PCW_CANT_CREATE_PATCH_FILE: u32 = 3222163718u32;
1433 pub const ERROR_PCW_CANT_CREATE_SUMMARY_INFO: u32 = 3222163828u32;
1434 pub const ERROR_PCW_CANT_CREATE_SUMMARY_INFO_POUND: u32 = 3222163830u32;
1435 pub const ERROR_PCW_CANT_CREATE_TEMP_FOLDER: u32 = 3222163715u32;
1436 pub const ERROR_PCW_CANT_DELETE_TEMP_FOLDER: u32 = 3222163974u32;
1437 pub const ERROR_PCW_CANT_GENERATE_SEQUENCEINFO_MAJORUPGD: u32 = 3222163842u32;
1438 pub const ERROR_PCW_CANT_GENERATE_TRANSFORM: u32 = 3222163827u32;
1439 pub const ERROR_PCW_CANT_GENERATE_TRANSFORM_POUND: u32 = 3222163829u32;
1440 pub const ERROR_PCW_CANT_OVERWRITE_PATCH: u32 = 3222163717u32;
1441 pub const ERROR_PCW_CANT_READ_FILE: u32 = 3222163978u32;
1442 pub const ERROR_PCW_CREATEFILE_LOG_FAILED: u32 = 3222163861u32;
1443 pub const ERROR_PCW_DUPLICATE_SEQUENCE_RECORD: u32 = 3222163858u32;
1444 pub const ERROR_PCW_DUP_IMAGE_FAMILY_NAME: u32 = 3222163749u32;
1445 pub const ERROR_PCW_DUP_TARGET_IMAGE_NAME: u32 = 3222163737u32;
1446 pub const ERROR_PCW_DUP_TARGET_IMAGE_PACKCODE: u32 = 3222163777u32;
1447 pub const ERROR_PCW_DUP_UPGRADED_IMAGE_NAME: u32 = 3222163729u32;
1448 pub const ERROR_PCW_DUP_UPGRADED_IMAGE_PACKCODE: u32 = 3222163795u32;
1449 pub const ERROR_PCW_ERROR_WRITING_TO_LOG: u32 = 3222163864u32;
1450 pub const ERROR_PCW_EXECUTE_VIEW: u32 = 3222163870u32;
1451 pub const ERROR_PCW_EXTFILE_BAD_FAMILY_FIELD: u32 = 3222163756u32;
1452 pub const ERROR_PCW_EXTFILE_BAD_IGNORE_LENGTHS: u32 = 3222163814u32;
1453 pub const ERROR_PCW_EXTFILE_BAD_IGNORE_OFFSETS: u32 = 3222163812u32;
1454 pub const ERROR_PCW_EXTFILE_BAD_RETAIN_OFFSETS: u32 = 3222163817u32;
1455 pub const ERROR_PCW_EXTFILE_BLANK_FILE_TABLE_KEY: u32 = 3222163755u32;
1456 pub const ERROR_PCW_EXTFILE_BLANK_PATH_TO_FILE: u32 = 3222163758u32;
1457 pub const ERROR_PCW_EXTFILE_IGNORE_COUNT_MISMATCH: u32 = 3222163815u32;
1458 pub const ERROR_PCW_EXTFILE_LONG_FILE_TABLE_KEY: u32 = 3222163754u32;
1459 pub const ERROR_PCW_EXTFILE_LONG_IGNORE_LENGTHS: u32 = 3222163813u32;
1460 pub const ERROR_PCW_EXTFILE_LONG_IGNORE_OFFSETS: u32 = 3222163811u32;
1461 pub const ERROR_PCW_EXTFILE_LONG_PATH_TO_FILE: u32 = 3222163757u32;
1462 pub const ERROR_PCW_EXTFILE_LONG_RETAIN_OFFSETS: u32 = 3222163816u32;
1463 pub const ERROR_PCW_EXTFILE_MISSING_FILE: u32 = 3222163759u32;
1464 pub const ERROR_PCW_FAILED_CREATE_TRANSFORM: u32 = 3222163973u32;
1465 pub const ERROR_PCW_FAILED_EXPAND_PATH: u32 = 3222163872u32;
1466 pub const ERROR_PCW_FAMILY_RANGE_BAD_RETAIN_LENGTHS: u32 = 3222163809u32;
1467 pub const ERROR_PCW_FAMILY_RANGE_BAD_RETAIN_OFFSETS: u32 = 3222163806u32;
1468 pub const ERROR_PCW_FAMILY_RANGE_BLANK_FILE_TABLE_KEY: u32 = 3222163803u32;
1469 pub const ERROR_PCW_FAMILY_RANGE_BLANK_RETAIN_LENGTHS: u32 = 3222163808u32;
1470 pub const ERROR_PCW_FAMILY_RANGE_BLANK_RETAIN_OFFSETS: u32 = 3222163805u32;
1471 pub const ERROR_PCW_FAMILY_RANGE_COUNT_MISMATCH: u32 = 3222163810u32;
1472 pub const ERROR_PCW_FAMILY_RANGE_LONG_FILE_TABLE_KEY: u32 = 3222163802u32;
1473 pub const ERROR_PCW_FAMILY_RANGE_LONG_RETAIN_LENGTHS: u32 = 3222163807u32;
1474 pub const ERROR_PCW_FAMILY_RANGE_LONG_RETAIN_OFFSETS: u32 = 3222163804u32;
1475 pub const ERROR_PCW_FAMILY_RANGE_NAME_TOO_LONG: u32 = 3222163800u32;
1476 pub const ERROR_PCW_IMAGE_FAMILY_NAME_TOO_LONG: u32 = 3222163747u32;
1477 pub const ERROR_PCW_IMAGE_PATH_NOT_EXIST: u32 = 3222163988u32;
1478 pub const ERROR_PCW_INTERNAL_ERROR: u32 = 3222163969u32;
1479 pub const ERROR_PCW_INVALID_LOG_LEVEL: u32 = 3222163862u32;
1480 pub const ERROR_PCW_INVALID_MAJOR_VERSION: u32 = 3222163990u32;
1481 pub const ERROR_PCW_INVALID_PARAMETER: u32 = 3222163860u32;
1482 pub const ERROR_PCW_INVALID_PATCHMETADATA_PROP: u32 = 3222163856u32;
1483 pub const ERROR_PCW_INVALID_PATCH_TYPE_SEQUENCING: u32 = 3222163977u32;
1484 pub const ERROR_PCW_INVALID_PCP_EXTERNALFILES: u32 = 3222163982u32;
1485 pub const ERROR_PCW_INVALID_PCP_FAMILYFILERANGES: u32 = 3222163992u32;
1486 pub const ERROR_PCW_INVALID_PCP_IMAGEFAMILIES: u32 = 3222163983u32;
1487 pub const ERROR_PCW_INVALID_PCP_PATCHSEQUENCE: u32 = 3222163984u32;
1488 pub const ERROR_PCW_INVALID_PCP_PROPERTIES: u32 = 3222163991u32;
1489 pub const ERROR_PCW_INVALID_PCP_PROPERTY: u32 = 3222163970u32;
1490 pub const ERROR_PCW_INVALID_PCP_TARGETFILES_OPTIONALDATA: u32 = 3222163985u32;
1491 pub const ERROR_PCW_INVALID_PCP_TARGETIMAGES: u32 = 3222163971u32;
1492 pub const ERROR_PCW_INVALID_PCP_UPGRADEDFILESTOIGNORE: u32 = 3222163980u32;
1493 pub const ERROR_PCW_INVALID_PCP_UPGRADEDFILES_OPTIONALDATA: u32 = 3222163986u32;
1494 pub const ERROR_PCW_INVALID_PCP_UPGRADEDIMAGES: u32 = 3222163981u32;
1495 pub const ERROR_PCW_INVALID_RANGE_ELEMENT: u32 = 3222163989u32;
1496 pub const ERROR_PCW_INVALID_SUPERCEDENCE: u32 = 3222163857u32;
1497 pub const ERROR_PCW_INVALID_SUPERSEDENCE_VALUE: u32 = 3222163976u32;
1498 pub const ERROR_PCW_INVALID_UI_LEVEL: u32 = 3222163863u32;
1499 pub const ERROR_PCW_LAX_VALIDATION_FLAGS: u32 = 3222163972u32;
1500 pub const ERROR_PCW_MAJOR_UPGD_WITHOUT_SEQUENCING: u32 = 3222163843u32;
1501 pub const ERROR_PCW_MATCHED_PRODUCT_VERSIONS: u32 = 3222163837u32;
1502 pub const ERROR_PCW_MISMATCHED_PRODUCT_CODES: u32 = 3222163779u32;
1503 pub const ERROR_PCW_MISMATCHED_PRODUCT_VERSIONS: u32 = 3222163780u32;
1504 pub const ERROR_PCW_MISSING_DIRECTORY_TABLE: u32 = 3222163975u32;
1505 pub const ERROR_PCW_MISSING_PATCHMETADATA: u32 = 3222163987u32;
1506 pub const ERROR_PCW_MISSING_PATCH_GUID: u32 = 3222163719u32;
1507 pub const ERROR_PCW_MISSING_PATCH_PATH: u32 = 3222163716u32;
1508 pub const ERROR_PCW_NO_UPGRADED_IMAGES_TO_PATCH: u32 = 3222163723u32;
1509 pub const ERROR_PCW_NULL_PATCHFAMILY: u32 = 3222163850u32;
1510 pub const ERROR_PCW_NULL_SEQUENCE_NUMBER: u32 = 3222163851u32;
1511 pub const ERROR_PCW_OBSOLETION_WITH_MSI30: u32 = 3222163839u32;
1512 pub const ERROR_PCW_OBSOLETION_WITH_PATCHSEQUENCE: u32 = 3222163840u32;
1513 pub const ERROR_PCW_OBSOLETION_WITH_SEQUENCE_DATA: u32 = 3222163838u32;
1514 pub const ERROR_PCW_OODS_COPYING_MSI: u32 = 3222163726u32;
1515 pub const ERROR_PCW_OPEN_VIEW: u32 = 3222163869u32;
1516 pub const ERROR_PCW_OUT_OF_MEMORY: u32 = 3222163865u32;
1517 pub const ERROR_PCW_PATCHMETADATA_PROP_NOT_SET: u32 = 3222163855u32;
1518 pub const ERROR_PCW_PCP_BAD_FORMAT: u32 = 3222163714u32;
1519 pub const ERROR_PCW_PCP_DOESNT_EXIST: u32 = 3222163713u32;
1520 pub const ERROR_PCW_SEQUENCING_BAD_TARGET: u32 = 3222163854u32;
1521 pub const ERROR_PCW_TARGET_BAD_PROD_CODE_VAL: u32 = 3222163744u32;
1522 pub const ERROR_PCW_TARGET_BAD_PROD_VALIDATE: u32 = 3222163743u32;
1523 pub const ERROR_PCW_TARGET_IMAGE_COMPRESSED: u32 = 3222163742u32;
1524 pub const ERROR_PCW_TARGET_IMAGE_NAME_TOO_LONG: u32 = 3222163735u32;
1525 pub const ERROR_PCW_TARGET_IMAGE_PATH_EMPTY: u32 = 3222163739u32;
1526 pub const ERROR_PCW_TARGET_IMAGE_PATH_NOT_EXIST: u32 = 3222163740u32;
1527 pub const ERROR_PCW_TARGET_IMAGE_PATH_NOT_MSI: u32 = 3222163741u32;
1528 pub const ERROR_PCW_TARGET_IMAGE_PATH_TOO_LONG: u32 = 3222163738u32;
1529 pub const ERROR_PCW_TARGET_MISSING_SRC_FILES: u32 = 3222163746u32;
1530 pub const ERROR_PCW_TARGET_WRONG_PRODUCT_VERSION_COMP: u32 = 3222163979u32;
1531 pub const ERROR_PCW_TFILEDATA_BAD_IGNORE_LENGTHS: u32 = 3222163822u32;
1532 pub const ERROR_PCW_TFILEDATA_BAD_IGNORE_OFFSETS: u32 = 3222163820u32;
1533 pub const ERROR_PCW_TFILEDATA_BAD_RETAIN_OFFSETS: u32 = 3222163825u32;
1534 pub const ERROR_PCW_TFILEDATA_BAD_TARGET_FIELD: u32 = 3222163791u32;
1535 pub const ERROR_PCW_TFILEDATA_BLANK_FILE_TABLE_KEY: u32 = 3222163789u32;
1536 pub const ERROR_PCW_TFILEDATA_IGNORE_COUNT_MISMATCH: u32 = 3222163823u32;
1537 pub const ERROR_PCW_TFILEDATA_LONG_FILE_TABLE_KEY: u32 = 3222163788u32;
1538 pub const ERROR_PCW_TFILEDATA_LONG_IGNORE_LENGTHS: u32 = 3222163821u32;
1539 pub const ERROR_PCW_TFILEDATA_LONG_IGNORE_OFFSETS: u32 = 3222163819u32;
1540 pub const ERROR_PCW_TFILEDATA_LONG_RETAIN_OFFSETS: u32 = 3222163824u32;
1541 pub const ERROR_PCW_TFILEDATA_MISSING_FILE_TABLE_KEY: u32 = 3222163790u32;
1542 pub const ERROR_PCW_UFILEDATA_BAD_UPGRADED_FIELD: u32 = 3222163778u32;
1543 pub const ERROR_PCW_UFILEDATA_BLANK_FILE_TABLE_KEY: u32 = 3222163752u32;
1544 pub const ERROR_PCW_UFILEDATA_LONG_FILE_TABLE_KEY: u32 = 3222163751u32;
1545 pub const ERROR_PCW_UFILEDATA_MISSING_FILE_TABLE_KEY: u32 = 3222163753u32;
1546 pub const ERROR_PCW_UFILEIGNORE_BAD_FILE_TABLE_KEY: u32 = 3222163799u32;
1547 pub const ERROR_PCW_UFILEIGNORE_BAD_UPGRADED_FIELD: u32 = 3222163796u32;
1548 pub const ERROR_PCW_UFILEIGNORE_BLANK_FILE_TABLE_KEY: u32 = 3222163798u32;
1549 pub const ERROR_PCW_UFILEIGNORE_LONG_FILE_TABLE_KEY: u32 = 3222163797u32;
1550 pub const ERROR_PCW_UNKNOWN_ERROR: u32 = 3222163866u32;
1551 pub const ERROR_PCW_UNKNOWN_INFO: u32 = 3222163867u32;
1552 pub const ERROR_PCW_UNKNOWN_WARN: u32 = 3222163868u32;
1553 pub const ERROR_PCW_UPGRADED_IMAGE_COMPRESSED: u32 = 3222163734u32;
1554 pub const ERROR_PCW_UPGRADED_IMAGE_NAME_TOO_LONG: u32 = 3222163727u32;
1555 pub const ERROR_PCW_UPGRADED_IMAGE_PATCH_PATH_NOT_EXIST: u32 = 3222163793u32;
1556 pub const ERROR_PCW_UPGRADED_IMAGE_PATCH_PATH_NOT_MSI: u32 = 3222163794u32;
1557 pub const ERROR_PCW_UPGRADED_IMAGE_PATCH_PATH_TOO_LONG: u32 = 3222163792u32;
1558 pub const ERROR_PCW_UPGRADED_IMAGE_PATH_EMPTY: u32 = 3222163731u32;
1559 pub const ERROR_PCW_UPGRADED_IMAGE_PATH_NOT_EXIST: u32 = 3222163732u32;
1560 pub const ERROR_PCW_UPGRADED_IMAGE_PATH_NOT_MSI: u32 = 3222163733u32;
1561 pub const ERROR_PCW_UPGRADED_IMAGE_PATH_TOO_LONG: u32 = 3222163730u32;
1562 pub const ERROR_PCW_UPGRADED_MISSING_SRC_FILES: u32 = 3222163745u32;
1563 pub const ERROR_PCW_VIEW_FETCH: u32 = 3222163871u32;
1564 pub const ERROR_PCW_WRITE_SUMMARY_PROPERTIES: u32 = 3222163787u32;
1565 pub const ERROR_PCW_WRONG_PATCHMETADATA_STRD_PROP: u32 = 3222163859u32;
1566 pub const ERROR_ROLLBACK_DISABLED: u32 = 1653u32;
1567 #[cfg(feature = "Win32_Foundation")]
1568 #[inline]
ExtractPatchHeaderToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, patchheaderfilename: Param1) -> super::super::Foundation::BOOL1569 pub unsafe fn ExtractPatchHeaderToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, patchheaderfilename: Param1) -> super::super::Foundation::BOOL {
1570     #[cfg(windows)]
1571     {
1572         #[link(name = "windows")]
1573         extern "system" {
1574             fn ExtractPatchHeaderToFileA(patchfilename: super::super::Foundation::PSTR, patchheaderfilename: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1575         }
1576         ::std::mem::transmute(ExtractPatchHeaderToFileA(patchfilename.into_param().abi(), patchheaderfilename.into_param().abi()))
1577     }
1578     #[cfg(not(windows))]
1579     unimplemented!("Unsupported target OS");
1580 }
1581 #[cfg(feature = "Win32_Foundation")]
1582 #[inline]
ExtractPatchHeaderToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, patchheaderfilehandle: Param1) -> super::super::Foundation::BOOL1583 pub unsafe fn ExtractPatchHeaderToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, patchheaderfilehandle: Param1) -> super::super::Foundation::BOOL {
1584     #[cfg(windows)]
1585     {
1586         #[link(name = "windows")]
1587         extern "system" {
1588             fn ExtractPatchHeaderToFileByHandles(patchfilehandle: super::super::Foundation::HANDLE, patchheaderfilehandle: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
1589         }
1590         ::std::mem::transmute(ExtractPatchHeaderToFileByHandles(patchfilehandle.into_param().abi(), patchheaderfilehandle.into_param().abi()))
1591     }
1592     #[cfg(not(windows))]
1593     unimplemented!("Unsupported target OS");
1594 }
1595 #[cfg(feature = "Win32_Foundation")]
1596 #[inline]
ExtractPatchHeaderToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, patchheaderfilename: Param1) -> super::super::Foundation::BOOL1597 pub unsafe fn ExtractPatchHeaderToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, patchheaderfilename: Param1) -> super::super::Foundation::BOOL {
1598     #[cfg(windows)]
1599     {
1600         #[link(name = "windows")]
1601         extern "system" {
1602             fn ExtractPatchHeaderToFileW(patchfilename: super::super::Foundation::PWSTR, patchheaderfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1603         }
1604         ::std::mem::transmute(ExtractPatchHeaderToFileW(patchfilename.into_param().abi(), patchheaderfilename.into_param().abi()))
1605     }
1606     #[cfg(not(windows))]
1607     unimplemented!("Unsupported target OS");
1608 }
1609 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1610 #[repr(C)]
1611 #[cfg(feature = "Win32_Foundation")]
1612 pub struct FUSION_INSTALL_REFERENCE {
1613     pub cbSize: u32,
1614     pub dwFlags: u32,
1615     pub guidScheme: ::windows::runtime::GUID,
1616     pub szIdentifier: super::super::Foundation::PWSTR,
1617     pub szNonCannonicalData: super::super::Foundation::PWSTR,
1618 }
1619 #[cfg(feature = "Win32_Foundation")]
1620 impl FUSION_INSTALL_REFERENCE {}
1621 #[cfg(feature = "Win32_Foundation")]
1622 impl ::std::default::Default for FUSION_INSTALL_REFERENCE {
default() -> Self1623     fn default() -> Self {
1624         unsafe { ::std::mem::zeroed() }
1625     }
1626 }
1627 #[cfg(feature = "Win32_Foundation")]
1628 impl ::std::fmt::Debug for FUSION_INSTALL_REFERENCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1629     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1630         fmt.debug_struct("FUSION_INSTALL_REFERENCE").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).field("guidScheme", &self.guidScheme).field("szIdentifier", &self.szIdentifier).field("szNonCannonicalData", &self.szNonCannonicalData).finish()
1631     }
1632 }
1633 #[cfg(feature = "Win32_Foundation")]
1634 impl ::std::cmp::PartialEq for FUSION_INSTALL_REFERENCE {
eq(&self, other: &Self) -> bool1635     fn eq(&self, other: &Self) -> bool {
1636         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.guidScheme == other.guidScheme && self.szIdentifier == other.szIdentifier && self.szNonCannonicalData == other.szNonCannonicalData
1637     }
1638 }
1639 #[cfg(feature = "Win32_Foundation")]
1640 impl ::std::cmp::Eq for FUSION_INSTALL_REFERENCE {}
1641 #[cfg(feature = "Win32_Foundation")]
1642 unsafe impl ::windows::runtime::Abi for FUSION_INSTALL_REFERENCE {
1643     type Abi = Self;
1644     type DefaultType = Self;
1645 }
1646 pub const FUSION_REFCOUNT_FILEPATH_GUID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2955910501, 64375, 20346, [175, 165, 179, 145, 48, 159, 17, 201]);
1647 pub const FUSION_REFCOUNT_OPAQUE_STRING_GUID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(784938083, 45251, 17889, [131, 100, 50, 126, 150, 174, 168, 86]);
1648 pub const FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2364391957, 44107, 18571, [147, 192, 165, 10, 73, 203, 47, 184]);
1649 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
1650 #[inline]
FindActCtxSectionGuid(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpguidtofind: *const ::windows::runtime::GUID, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL1651 pub unsafe fn FindActCtxSectionGuid(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpguidtofind: *const ::windows::runtime::GUID, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL {
1652     #[cfg(windows)]
1653     {
1654         #[link(name = "windows")]
1655         extern "system" {
1656             fn FindActCtxSectionGuid(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpguidtofind: *const ::windows::runtime::GUID, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL;
1657         }
1658         ::std::mem::transmute(FindActCtxSectionGuid(::std::mem::transmute(dwflags), ::std::mem::transmute(lpextensionguid), ::std::mem::transmute(ulsectionid), ::std::mem::transmute(lpguidtofind), ::std::mem::transmute(returneddata)))
1659     }
1660     #[cfg(not(windows))]
1661     unimplemented!("Unsupported target OS");
1662 }
1663 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
1664 #[inline]
FindActCtxSectionStringA<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: Param3, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL1665 pub unsafe fn FindActCtxSectionStringA<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: Param3, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL {
1666     #[cfg(windows)]
1667     {
1668         #[link(name = "windows")]
1669         extern "system" {
1670             fn FindActCtxSectionStringA(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: super::super::Foundation::PSTR, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL;
1671         }
1672         ::std::mem::transmute(FindActCtxSectionStringA(::std::mem::transmute(dwflags), ::std::mem::transmute(lpextensionguid), ::std::mem::transmute(ulsectionid), lpstringtofind.into_param().abi(), ::std::mem::transmute(returneddata)))
1673     }
1674     #[cfg(not(windows))]
1675     unimplemented!("Unsupported target OS");
1676 }
1677 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
1678 #[inline]
FindActCtxSectionStringW<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: Param3, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL1679 pub unsafe fn FindActCtxSectionStringW<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: Param3, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL {
1680     #[cfg(windows)]
1681     {
1682         #[link(name = "windows")]
1683         extern "system" {
1684             fn FindActCtxSectionStringW(dwflags: u32, lpextensionguid: *const ::windows::runtime::GUID, ulsectionid: u32, lpstringtofind: super::super::Foundation::PWSTR, returneddata: *mut ACTCTX_SECTION_KEYED_DATA) -> super::super::Foundation::BOOL;
1685         }
1686         ::std::mem::transmute(FindActCtxSectionStringW(::std::mem::transmute(dwflags), ::std::mem::transmute(lpextensionguid), ::std::mem::transmute(ulsectionid), lpstringtofind.into_param().abi(), ::std::mem::transmute(returneddata)))
1687     }
1688     #[cfg(not(windows))]
1689     unimplemented!("Unsupported target OS");
1690 }
1691 #[cfg(feature = "Win32_Foundation")]
1692 #[inline]
GetCurrentActCtx(lphactctx: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL1693 pub unsafe fn GetCurrentActCtx(lphactctx: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL {
1694     #[cfg(windows)]
1695     {
1696         #[link(name = "windows")]
1697         extern "system" {
1698             fn GetCurrentActCtx(lphactctx: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
1699         }
1700         ::std::mem::transmute(GetCurrentActCtx(::std::mem::transmute(lphactctx)))
1701     }
1702     #[cfg(not(windows))]
1703     unimplemented!("Unsupported target OS");
1704 }
1705 #[cfg(feature = "Win32_Foundation")]
1706 #[inline]
GetDeltaInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpdeltaname: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL1707 pub unsafe fn GetDeltaInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpdeltaname: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL {
1708     #[cfg(windows)]
1709     {
1710         #[link(name = "windows")]
1711         extern "system" {
1712             fn GetDeltaInfoA(lpdeltaname: super::super::Foundation::PSTR, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL;
1713         }
1714         ::std::mem::transmute(GetDeltaInfoA(lpdeltaname.into_param().abi(), ::std::mem::transmute(lpheaderinfo)))
1715     }
1716     #[cfg(not(windows))]
1717     unimplemented!("Unsupported target OS");
1718 }
1719 #[cfg(feature = "Win32_Foundation")]
1720 #[inline]
GetDeltaInfoB<'a, Param0: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(delta: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL1721 pub unsafe fn GetDeltaInfoB<'a, Param0: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(delta: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL {
1722     #[cfg(windows)]
1723     {
1724         #[link(name = "windows")]
1725         extern "system" {
1726             fn GetDeltaInfoB(delta: DELTA_INPUT, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL;
1727         }
1728         ::std::mem::transmute(GetDeltaInfoB(delta.into_param().abi(), ::std::mem::transmute(lpheaderinfo)))
1729     }
1730     #[cfg(not(windows))]
1731     unimplemented!("Unsupported target OS");
1732 }
1733 #[cfg(feature = "Win32_Foundation")]
1734 #[inline]
GetDeltaInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpdeltaname: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL1735 pub unsafe fn GetDeltaInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpdeltaname: Param0, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL {
1736     #[cfg(windows)]
1737     {
1738         #[link(name = "windows")]
1739         extern "system" {
1740             fn GetDeltaInfoW(lpdeltaname: super::super::Foundation::PWSTR, lpheaderinfo: *mut DELTA_HEADER_INFO) -> super::super::Foundation::BOOL;
1741         }
1742         ::std::mem::transmute(GetDeltaInfoW(lpdeltaname.into_param().abi(), ::std::mem::transmute(lpheaderinfo)))
1743     }
1744     #[cfg(not(windows))]
1745     unimplemented!("Unsupported target OS");
1746 }
1747 #[cfg(feature = "Win32_Foundation")]
1748 #[inline]
GetDeltaSignatureA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(filetypeset: i64, hashalgid: u32, lpsourcename: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL1749 pub unsafe fn GetDeltaSignatureA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(filetypeset: i64, hashalgid: u32, lpsourcename: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL {
1750     #[cfg(windows)]
1751     {
1752         #[link(name = "windows")]
1753         extern "system" {
1754             fn GetDeltaSignatureA(filetypeset: i64, hashalgid: u32, lpsourcename: super::super::Foundation::PSTR, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL;
1755         }
1756         ::std::mem::transmute(GetDeltaSignatureA(::std::mem::transmute(filetypeset), ::std::mem::transmute(hashalgid), lpsourcename.into_param().abi(), ::std::mem::transmute(lphash)))
1757     }
1758     #[cfg(not(windows))]
1759     unimplemented!("Unsupported target OS");
1760 }
1761 #[cfg(feature = "Win32_Foundation")]
1762 #[inline]
GetDeltaSignatureB<'a, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(filetypeset: i64, hashalgid: u32, source: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL1763 pub unsafe fn GetDeltaSignatureB<'a, Param2: ::windows::runtime::IntoParam<'a, DELTA_INPUT>>(filetypeset: i64, hashalgid: u32, source: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL {
1764     #[cfg(windows)]
1765     {
1766         #[link(name = "windows")]
1767         extern "system" {
1768             fn GetDeltaSignatureB(filetypeset: i64, hashalgid: u32, source: DELTA_INPUT, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL;
1769         }
1770         ::std::mem::transmute(GetDeltaSignatureB(::std::mem::transmute(filetypeset), ::std::mem::transmute(hashalgid), source.into_param().abi(), ::std::mem::transmute(lphash)))
1771     }
1772     #[cfg(not(windows))]
1773     unimplemented!("Unsupported target OS");
1774 }
1775 #[cfg(feature = "Win32_Foundation")]
1776 #[inline]
GetDeltaSignatureW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filetypeset: i64, hashalgid: u32, lpsourcename: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL1777 pub unsafe fn GetDeltaSignatureW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filetypeset: i64, hashalgid: u32, lpsourcename: Param2, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL {
1778     #[cfg(windows)]
1779     {
1780         #[link(name = "windows")]
1781         extern "system" {
1782             fn GetDeltaSignatureW(filetypeset: i64, hashalgid: u32, lpsourcename: super::super::Foundation::PWSTR, lphash: *mut DELTA_HASH) -> super::super::Foundation::BOOL;
1783         }
1784         ::std::mem::transmute(GetDeltaSignatureW(::std::mem::transmute(filetypeset), ::std::mem::transmute(hashalgid), lpsourcename.into_param().abi(), ::std::mem::transmute(lphash)))
1785     }
1786     #[cfg(not(windows))]
1787     unimplemented!("Unsupported target OS");
1788 }
1789 #[cfg(feature = "Win32_Foundation")]
1790 #[inline]
GetFilePatchSignatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(filename: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL1791 pub unsafe fn GetFilePatchSignatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(filename: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL {
1792     #[cfg(windows)]
1793     {
1794         #[link(name = "windows")]
1795         extern "system" {
1796             fn GetFilePatchSignatureA(filename: super::super::Foundation::PSTR, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1797         }
1798         ::std::mem::transmute(GetFilePatchSignatureA(
1799             filename.into_param().abi(),
1800             ::std::mem::transmute(optionflags),
1801             ::std::mem::transmute(optiondata),
1802             ::std::mem::transmute(ignorerangecount),
1803             ::std::mem::transmute(ignorerangearray),
1804             ::std::mem::transmute(retainrangecount),
1805             ::std::mem::transmute(retainrangearray),
1806             ::std::mem::transmute(signaturebuffersize),
1807             ::std::mem::transmute(signaturebuffer),
1808         ))
1809     }
1810     #[cfg(not(windows))]
1811     unimplemented!("Unsupported target OS");
1812 }
1813 #[cfg(feature = "Win32_Foundation")]
1814 #[inline]
GetFilePatchSignatureByBuffer(filebufferwritable: *mut u8, filesize: u32, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL1815 pub unsafe fn GetFilePatchSignatureByBuffer(filebufferwritable: *mut u8, filesize: u32, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL {
1816     #[cfg(windows)]
1817     {
1818         #[link(name = "windows")]
1819         extern "system" {
1820             fn GetFilePatchSignatureByBuffer(filebufferwritable: *mut u8, filesize: u32, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1821         }
1822         ::std::mem::transmute(GetFilePatchSignatureByBuffer(
1823             ::std::mem::transmute(filebufferwritable),
1824             ::std::mem::transmute(filesize),
1825             ::std::mem::transmute(optionflags),
1826             ::std::mem::transmute(optiondata),
1827             ::std::mem::transmute(ignorerangecount),
1828             ::std::mem::transmute(ignorerangearray),
1829             ::std::mem::transmute(retainrangecount),
1830             ::std::mem::transmute(retainrangearray),
1831             ::std::mem::transmute(signaturebuffersize),
1832             ::std::mem::transmute(signaturebuffer),
1833         ))
1834     }
1835     #[cfg(not(windows))]
1836     unimplemented!("Unsupported target OS");
1837 }
1838 #[cfg(feature = "Win32_Foundation")]
1839 #[inline]
GetFilePatchSignatureByHandle<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(filehandle: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL1840 pub unsafe fn GetFilePatchSignatureByHandle<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(filehandle: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL {
1841     #[cfg(windows)]
1842     {
1843         #[link(name = "windows")]
1844         extern "system" {
1845             fn GetFilePatchSignatureByHandle(filehandle: super::super::Foundation::HANDLE, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
1846         }
1847         ::std::mem::transmute(GetFilePatchSignatureByHandle(
1848             filehandle.into_param().abi(),
1849             ::std::mem::transmute(optionflags),
1850             ::std::mem::transmute(optiondata),
1851             ::std::mem::transmute(ignorerangecount),
1852             ::std::mem::transmute(ignorerangearray),
1853             ::std::mem::transmute(retainrangecount),
1854             ::std::mem::transmute(retainrangearray),
1855             ::std::mem::transmute(signaturebuffersize),
1856             ::std::mem::transmute(signaturebuffer),
1857         ))
1858     }
1859     #[cfg(not(windows))]
1860     unimplemented!("Unsupported target OS");
1861 }
1862 #[cfg(feature = "Win32_Foundation")]
1863 #[inline]
GetFilePatchSignatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filename: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL1864 pub unsafe fn GetFilePatchSignatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filename: Param0, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL {
1865     #[cfg(windows)]
1866     {
1867         #[link(name = "windows")]
1868         extern "system" {
1869             fn GetFilePatchSignatureW(filename: super::super::Foundation::PWSTR, optionflags: u32, optiondata: *const ::std::ffi::c_void, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE, signaturebuffersize: u32, signaturebuffer: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
1870         }
1871         ::std::mem::transmute(GetFilePatchSignatureW(
1872             filename.into_param().abi(),
1873             ::std::mem::transmute(optionflags),
1874             ::std::mem::transmute(optiondata),
1875             ::std::mem::transmute(ignorerangecount),
1876             ::std::mem::transmute(ignorerangearray),
1877             ::std::mem::transmute(retainrangecount),
1878             ::std::mem::transmute(retainrangearray),
1879             ::std::mem::transmute(signaturebuffersize),
1880             ::std::mem::transmute(signaturebuffer),
1881         ))
1882     }
1883     #[cfg(not(windows))]
1884     unimplemented!("Unsupported target OS");
1885 }
1886 pub const IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_ALREADY_INSTALLED: u32 = 3u32;
1887 pub const IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_INSTALLED: u32 = 1u32;
1888 pub const IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_REFRESHED: u32 = 2u32;
1889 pub const IASSEMBLYCACHEITEM_COMMIT_FLAG_REFRESH: u32 = 1u32;
1890 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1891 #[repr(transparent)]
1892 pub struct IASSEMBLYCACHE_UNINSTALL_DISPOSITION(pub u32);
1893 pub const IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED: IASSEMBLYCACHE_UNINSTALL_DISPOSITION = IASSEMBLYCACHE_UNINSTALL_DISPOSITION(1u32);
1894 pub const IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE: IASSEMBLYCACHE_UNINSTALL_DISPOSITION = IASSEMBLYCACHE_UNINSTALL_DISPOSITION(2u32);
1895 pub const IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED: IASSEMBLYCACHE_UNINSTALL_DISPOSITION = IASSEMBLYCACHE_UNINSTALL_DISPOSITION(3u32);
1896 pub const IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING: IASSEMBLYCACHE_UNINSTALL_DISPOSITION = IASSEMBLYCACHE_UNINSTALL_DISPOSITION(4u32);
1897 impl ::std::convert::From<u32> for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
from(value: u32) -> Self1898     fn from(value: u32) -> Self {
1899         Self(value)
1900     }
1901 }
1902 unsafe impl ::windows::runtime::Abi for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
1903     type Abi = Self;
1904     type DefaultType = Self;
1905 }
1906 impl ::std::ops::BitOr for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
1907     type Output = Self;
bitor(self, rhs: Self) -> Self1908     fn bitor(self, rhs: Self) -> Self {
1909         Self(self.0 | rhs.0)
1910     }
1911 }
1912 impl ::std::ops::BitAnd for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
1913     type Output = Self;
bitand(self, rhs: Self) -> Self1914     fn bitand(self, rhs: Self) -> Self {
1915         Self(self.0 & rhs.0)
1916     }
1917 }
1918 impl ::std::ops::BitOrAssign for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
bitor_assign(&mut self, rhs: Self)1919     fn bitor_assign(&mut self, rhs: Self) {
1920         self.0.bitor_assign(rhs.0)
1921     }
1922 }
1923 impl ::std::ops::BitAndAssign for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
bitand_assign(&mut self, rhs: Self)1924     fn bitand_assign(&mut self, rhs: Self) {
1925         self.0.bitand_assign(rhs.0)
1926     }
1927 }
1928 impl ::std::ops::Not for IASSEMBLYCACHE_UNINSTALL_DISPOSITION {
1929     type Output = Self;
not(self) -> Self1930     fn not(self) -> Self {
1931         Self(self.0.not())
1932     }
1933 }
1934 #[repr(transparent)]
1935 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1936 pub struct IAssemblyCache(::windows::runtime::IUnknown);
1937 impl IAssemblyCache {
1938     #[cfg(feature = "Win32_Foundation")]
UninstallAssembly<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszassemblyname: Param1, prefdata: *mut FUSION_INSTALL_REFERENCE, puldisposition: *mut IASSEMBLYCACHE_UNINSTALL_DISPOSITION) -> ::windows::runtime::Result<()>1939     pub unsafe fn UninstallAssembly<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszassemblyname: Param1, prefdata: *mut FUSION_INSTALL_REFERENCE, puldisposition: *mut IASSEMBLYCACHE_UNINSTALL_DISPOSITION) -> ::windows::runtime::Result<()> {
1940         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), pszassemblyname.into_param().abi(), ::std::mem::transmute(prefdata), ::std::mem::transmute(puldisposition)).ok()
1941     }
1942     #[cfg(feature = "Win32_Foundation")]
QueryAssemblyInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: QUERYASMINFO_FLAGS, pszassemblyname: Param1, pasminfo: *mut ASSEMBLY_INFO) -> ::windows::runtime::Result<()>1943     pub unsafe fn QueryAssemblyInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: QUERYASMINFO_FLAGS, pszassemblyname: Param1, pasminfo: *mut ASSEMBLY_INFO) -> ::windows::runtime::Result<()> {
1944         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), pszassemblyname.into_param().abi(), ::std::mem::transmute(pasminfo)).ok()
1945     }
1946     #[cfg(feature = "Win32_Foundation")]
CreateAssemblyCacheItem<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppasmitem: *mut ::std::option::Option<IAssemblyCacheItem>, pszassemblyname: Param3) -> ::windows::runtime::Result<()>1947     pub unsafe fn CreateAssemblyCacheItem<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppasmitem: *mut ::std::option::Option<IAssemblyCacheItem>, pszassemblyname: Param3) -> ::windows::runtime::Result<()> {
1948         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(ppasmitem), pszassemblyname.into_param().abi()).ok()
1949     }
Reserved(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown>1950     pub unsafe fn Reserved(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown> {
1951         let mut result__: <::windows::runtime::IUnknown as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1952         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::IUnknown>(result__)
1953     }
1954     #[cfg(feature = "Win32_Foundation")]
InstallAssembly<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszmanifestfilepath: Param1, prefdata: *mut FUSION_INSTALL_REFERENCE) -> ::windows::runtime::Result<()>1955     pub unsafe fn InstallAssembly<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszmanifestfilepath: Param1, prefdata: *mut FUSION_INSTALL_REFERENCE) -> ::windows::runtime::Result<()> {
1956         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), pszmanifestfilepath.into_param().abi(), ::std::mem::transmute(prefdata)).ok()
1957     }
1958 }
1959 unsafe impl ::windows::runtime::Interface for IAssemblyCache {
1960     type Vtable = IAssemblyCache_abi;
1961     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3876052190, 53709, 4562, [186, 185, 0, 192, 79, 142, 206, 174]);
1962 }
1963 impl ::std::convert::From<IAssemblyCache> for ::windows::runtime::IUnknown {
from(value: IAssemblyCache) -> Self1964     fn from(value: IAssemblyCache) -> Self {
1965         unsafe { ::std::mem::transmute(value) }
1966     }
1967 }
1968 impl ::std::convert::From<&IAssemblyCache> for ::windows::runtime::IUnknown {
from(value: &IAssemblyCache) -> Self1969     fn from(value: &IAssemblyCache) -> Self {
1970         ::std::convert::From::from(::std::clone::Clone::clone(value))
1971     }
1972 }
1973 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IAssemblyCache {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1974     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1975         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1976     }
1977 }
1978 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IAssemblyCache {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>1979     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1980         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1981     }
1982 }
1983 #[repr(C)]
1984 #[doc(hidden)]
1985 pub struct IAssemblyCache_abi(
1986     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1987     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1988     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1989     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, pszassemblyname: super::super::Foundation::PWSTR, prefdata: *mut FUSION_INSTALL_REFERENCE, puldisposition: *mut IASSEMBLYCACHE_UNINSTALL_DISPOSITION) -> ::windows::runtime::HRESULT,
1990     #[cfg(not(feature = "Win32_Foundation"))] usize,
1991     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: QUERYASMINFO_FLAGS, pszassemblyname: super::super::Foundation::PWSTR, pasminfo: *mut ASSEMBLY_INFO) -> ::windows::runtime::HRESULT,
1992     #[cfg(not(feature = "Win32_Foundation"))] usize,
1993     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppasmitem: *mut ::windows::runtime::RawPtr, pszassemblyname: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1994     #[cfg(not(feature = "Win32_Foundation"))] usize,
1995     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppunk: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1996     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, pszmanifestfilepath: super::super::Foundation::PWSTR, prefdata: *mut FUSION_INSTALL_REFERENCE) -> ::windows::runtime::HRESULT,
1997     #[cfg(not(feature = "Win32_Foundation"))] usize,
1998 );
1999 #[repr(transparent)]
2000 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2001 pub struct IAssemblyCacheItem(::windows::runtime::IUnknown);
2002 impl IAssemblyCacheItem {
2003     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
CreateStream<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszstreamname: Param1, dwformat: u32, dwformatflags: u32, ppistream: *mut ::std::option::Option<super::Com::IStream>, pulimaxsize: *mut u64) -> ::windows::runtime::Result<()>2004     pub unsafe fn CreateStream<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, dwflags: u32, pszstreamname: Param1, dwformat: u32, dwformatflags: u32, ppistream: *mut ::std::option::Option<super::Com::IStream>, pulimaxsize: *mut u64) -> ::windows::runtime::Result<()> {
2005         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), pszstreamname.into_param().abi(), ::std::mem::transmute(dwformat), ::std::mem::transmute(dwformatflags), ::std::mem::transmute(ppistream), ::std::mem::transmute(pulimaxsize)).ok()
2006     }
Commit(&self, dwflags: u32, puldisposition: *mut u32) -> ::windows::runtime::Result<()>2007     pub unsafe fn Commit(&self, dwflags: u32, puldisposition: *mut u32) -> ::windows::runtime::Result<()> {
2008         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), ::std::mem::transmute(puldisposition)).ok()
2009     }
AbortItem(&self) -> ::windows::runtime::Result<()>2010     pub unsafe fn AbortItem(&self) -> ::windows::runtime::Result<()> {
2011         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2012     }
2013 }
2014 unsafe impl ::windows::runtime::Interface for IAssemblyCacheItem {
2015     type Vtable = IAssemblyCacheItem_abi;
2016     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2654645940, 53709, 4562, [186, 185, 0, 192, 79, 142, 206, 174]);
2017 }
2018 impl ::std::convert::From<IAssemblyCacheItem> for ::windows::runtime::IUnknown {
from(value: IAssemblyCacheItem) -> Self2019     fn from(value: IAssemblyCacheItem) -> Self {
2020         unsafe { ::std::mem::transmute(value) }
2021     }
2022 }
2023 impl ::std::convert::From<&IAssemblyCacheItem> for ::windows::runtime::IUnknown {
from(value: &IAssemblyCacheItem) -> Self2024     fn from(value: &IAssemblyCacheItem) -> Self {
2025         ::std::convert::From::from(::std::clone::Clone::clone(value))
2026     }
2027 }
2028 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IAssemblyCacheItem {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2029     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2030         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2031     }
2032 }
2033 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IAssemblyCacheItem {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2034     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2035         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2036     }
2037 }
2038 #[repr(C)]
2039 #[doc(hidden)]
2040 pub struct IAssemblyCacheItem_abi(
2041     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2042     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2043     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2044     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, pszstreamname: super::super::Foundation::PWSTR, dwformat: u32, dwformatflags: u32, ppistream: *mut ::windows::runtime::RawPtr, pulimaxsize: *mut u64) -> ::windows::runtime::HRESULT,
2045     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
2046     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, puldisposition: *mut u32) -> ::windows::runtime::HRESULT,
2047     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2048 );
2049 #[repr(transparent)]
2050 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2051 pub struct IAssemblyName(::windows::runtime::IUnknown);
2052 impl IAssemblyName {
SetProperty(&self, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, cbproperty: u32) -> ::windows::runtime::Result<()>2053     pub unsafe fn SetProperty(&self, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, cbproperty: u32) -> ::windows::runtime::Result<()> {
2054         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(pvproperty), ::std::mem::transmute(cbproperty)).ok()
2055     }
GetProperty(&self, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, pcbproperty: *mut u32) -> ::windows::runtime::Result<()>2056     pub unsafe fn GetProperty(&self, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, pcbproperty: *mut u32) -> ::windows::runtime::Result<()> {
2057         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(pvproperty), ::std::mem::transmute(pcbproperty)).ok()
2058     }
Finalize(&self) -> ::windows::runtime::Result<()>2059     pub unsafe fn Finalize(&self) -> ::windows::runtime::Result<()> {
2060         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2061     }
2062     #[cfg(feature = "Win32_Foundation")]
GetDisplayName(&self, szdisplayname: super::super::Foundation::PWSTR, pccdisplayname: *mut u32, dwdisplayflags: u32) -> ::windows::runtime::Result<()>2063     pub unsafe fn GetDisplayName(&self, szdisplayname: super::super::Foundation::PWSTR, pccdisplayname: *mut u32, dwdisplayflags: u32) -> ::windows::runtime::Result<()> {
2064         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(szdisplayname), ::std::mem::transmute(pccdisplayname), ::std::mem::transmute(dwdisplayflags)).ok()
2065     }
2066     #[cfg(feature = "Win32_Foundation")]
Reserved<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( &self, refiid: *const ::windows::runtime::GUID, punkreserved1: Param1, punkreserved2: Param2, szreserved: Param3, llreserved: i64, pvreserved: *mut ::std::ffi::c_void, cbreserved: u32, ppreserved: *mut *mut ::std::ffi::c_void, ) -> ::windows::runtime::Result<()>2067     pub unsafe fn Reserved<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
2068         &self,
2069         refiid: *const ::windows::runtime::GUID,
2070         punkreserved1: Param1,
2071         punkreserved2: Param2,
2072         szreserved: Param3,
2073         llreserved: i64,
2074         pvreserved: *mut ::std::ffi::c_void,
2075         cbreserved: u32,
2076         ppreserved: *mut *mut ::std::ffi::c_void,
2077     ) -> ::windows::runtime::Result<()> {
2078         (::windows::runtime::Interface::vtable(self).7)(
2079             ::std::mem::transmute_copy(self),
2080             ::std::mem::transmute(refiid),
2081             punkreserved1.into_param().abi(),
2082             punkreserved2.into_param().abi(),
2083             szreserved.into_param().abi(),
2084             ::std::mem::transmute(llreserved),
2085             ::std::mem::transmute(pvreserved),
2086             ::std::mem::transmute(cbreserved),
2087             ::std::mem::transmute(ppreserved),
2088         )
2089         .ok()
2090     }
2091     #[cfg(feature = "Win32_Foundation")]
GetName(&self, lpcwbuffer: *mut u32, pwzname: super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()>2092     pub unsafe fn GetName(&self, lpcwbuffer: *mut u32, pwzname: super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
2093         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(lpcwbuffer), ::std::mem::transmute(pwzname)).ok()
2094     }
GetVersion(&self, pdwversionhi: *mut u32, pdwversionlow: *mut u32) -> ::windows::runtime::Result<()>2095     pub unsafe fn GetVersion(&self, pdwversionhi: *mut u32, pdwversionlow: *mut u32) -> ::windows::runtime::Result<()> {
2096         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwversionhi), ::std::mem::transmute(pdwversionlow)).ok()
2097     }
IsEqual<'a, Param0: ::windows::runtime::IntoParam<'a, IAssemblyName>>(&self, pname: Param0, dwcmpflags: u32) -> ::windows::runtime::Result<()>2098     pub unsafe fn IsEqual<'a, Param0: ::windows::runtime::IntoParam<'a, IAssemblyName>>(&self, pname: Param0, dwcmpflags: u32) -> ::windows::runtime::Result<()> {
2099         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), pname.into_param().abi(), ::std::mem::transmute(dwcmpflags)).ok()
2100     }
Clone(&self) -> ::windows::runtime::Result<IAssemblyName>2101     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IAssemblyName> {
2102         let mut result__: <IAssemblyName as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2103         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IAssemblyName>(result__)
2104     }
2105 }
2106 unsafe impl ::windows::runtime::Interface for IAssemblyName {
2107     type Vtable = IAssemblyName_abi;
2108     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3440982976, 46268, 4562, [152, 51, 0, 192, 79, 195, 29, 46]);
2109 }
2110 impl ::std::convert::From<IAssemblyName> for ::windows::runtime::IUnknown {
from(value: IAssemblyName) -> Self2111     fn from(value: IAssemblyName) -> Self {
2112         unsafe { ::std::mem::transmute(value) }
2113     }
2114 }
2115 impl ::std::convert::From<&IAssemblyName> for ::windows::runtime::IUnknown {
from(value: &IAssemblyName) -> Self2116     fn from(value: &IAssemblyName) -> Self {
2117         ::std::convert::From::from(::std::clone::Clone::clone(value))
2118     }
2119 }
2120 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IAssemblyName {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2121     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2122         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2123     }
2124 }
2125 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IAssemblyName {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2126     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2127         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2128     }
2129 }
2130 #[repr(C)]
2131 #[doc(hidden)]
2132 pub struct IAssemblyName_abi(
2133     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2134     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2135     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2136     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, cbproperty: u32) -> ::windows::runtime::HRESULT,
2137     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: u32, pvproperty: *mut ::std::ffi::c_void, pcbproperty: *mut u32) -> ::windows::runtime::HRESULT,
2138     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2139     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, szdisplayname: super::super::Foundation::PWSTR, pccdisplayname: *mut u32, dwdisplayflags: u32) -> ::windows::runtime::HRESULT,
2140     #[cfg(not(feature = "Win32_Foundation"))] usize,
2141     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, refiid: *const ::windows::runtime::GUID, punkreserved1: ::windows::runtime::RawPtr, punkreserved2: ::windows::runtime::RawPtr, szreserved: super::super::Foundation::PWSTR, llreserved: i64, pvreserved: *mut ::std::ffi::c_void, cbreserved: u32, ppreserved: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
2142     #[cfg(not(feature = "Win32_Foundation"))] usize,
2143     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lpcwbuffer: *mut u32, pwzname: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
2144     #[cfg(not(feature = "Win32_Foundation"))] usize,
2145     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwversionhi: *mut u32, pdwversionlow: *mut u32) -> ::windows::runtime::HRESULT,
2146     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pname: ::windows::runtime::RawPtr, dwcmpflags: u32) -> ::windows::runtime::HRESULT,
2147     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pname: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2148 );
2149 #[repr(transparent)]
2150 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2151 pub struct IEnumMsmDependency(::windows::runtime::IUnknown);
2152 impl IEnumMsmDependency {
Next(&self, cfetch: u32, rgmsmdependencies: *mut ::std::option::Option<IMsmDependency>, pcfetched: *mut u32) -> ::windows::runtime::Result<()>2153     pub unsafe fn Next(&self, cfetch: u32, rgmsmdependencies: *mut ::std::option::Option<IMsmDependency>, pcfetched: *mut u32) -> ::windows::runtime::Result<()> {
2154         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(cfetch), ::std::mem::transmute(rgmsmdependencies), ::std::mem::transmute(pcfetched)).ok()
2155     }
Skip(&self, cskip: u32) -> ::windows::runtime::Result<()>2156     pub unsafe fn Skip(&self, cskip: u32) -> ::windows::runtime::Result<()> {
2157         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cskip)).ok()
2158     }
Reset(&self) -> ::windows::runtime::Result<()>2159     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2160         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2161     }
Clone(&self) -> ::windows::runtime::Result<IEnumMsmDependency>2162     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumMsmDependency> {
2163         let mut result__: <IEnumMsmDependency as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2164         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumMsmDependency>(result__)
2165     }
2166 }
2167 unsafe impl ::windows::runtime::Interface for IEnumMsmDependency {
2168     type Vtable = IEnumMsmDependency_abi;
2169     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298668, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2170 }
2171 impl ::std::convert::From<IEnumMsmDependency> for ::windows::runtime::IUnknown {
from(value: IEnumMsmDependency) -> Self2172     fn from(value: IEnumMsmDependency) -> Self {
2173         unsafe { ::std::mem::transmute(value) }
2174     }
2175 }
2176 impl ::std::convert::From<&IEnumMsmDependency> for ::windows::runtime::IUnknown {
from(value: &IEnumMsmDependency) -> Self2177     fn from(value: &IEnumMsmDependency) -> Self {
2178         ::std::convert::From::from(::std::clone::Clone::clone(value))
2179     }
2180 }
2181 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2182     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2183         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2184     }
2185 }
2186 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2187     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2188         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2189     }
2190 }
2191 #[repr(C)]
2192 #[doc(hidden)]
2193 pub struct IEnumMsmDependency_abi(
2194     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2195     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2196     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2197     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cfetch: u32, rgmsmdependencies: *mut ::windows::runtime::RawPtr, pcfetched: *mut u32) -> ::windows::runtime::HRESULT,
2198     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cskip: u32) -> ::windows::runtime::HRESULT,
2199     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2200     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pemsmdependencies: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2201 );
2202 #[repr(transparent)]
2203 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2204 pub struct IEnumMsmError(::windows::runtime::IUnknown);
2205 impl IEnumMsmError {
Next(&self, cfetch: u32, rgmsmerrors: *mut ::std::option::Option<IMsmError>, pcfetched: *mut u32) -> ::windows::runtime::Result<()>2206     pub unsafe fn Next(&self, cfetch: u32, rgmsmerrors: *mut ::std::option::Option<IMsmError>, pcfetched: *mut u32) -> ::windows::runtime::Result<()> {
2207         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(cfetch), ::std::mem::transmute(rgmsmerrors), ::std::mem::transmute(pcfetched)).ok()
2208     }
Skip(&self, cskip: u32) -> ::windows::runtime::Result<()>2209     pub unsafe fn Skip(&self, cskip: u32) -> ::windows::runtime::Result<()> {
2210         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cskip)).ok()
2211     }
Reset(&self) -> ::windows::runtime::Result<()>2212     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2213         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2214     }
Clone(&self) -> ::windows::runtime::Result<IEnumMsmError>2215     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumMsmError> {
2216         let mut result__: <IEnumMsmError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2217         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumMsmError>(result__)
2218     }
2219 }
2220 unsafe impl ::windows::runtime::Interface for IEnumMsmError {
2221     type Vtable = IEnumMsmError_abi;
2222     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298665, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2223 }
2224 impl ::std::convert::From<IEnumMsmError> for ::windows::runtime::IUnknown {
from(value: IEnumMsmError) -> Self2225     fn from(value: IEnumMsmError) -> Self {
2226         unsafe { ::std::mem::transmute(value) }
2227     }
2228 }
2229 impl ::std::convert::From<&IEnumMsmError> for ::windows::runtime::IUnknown {
from(value: &IEnumMsmError) -> Self2230     fn from(value: &IEnumMsmError) -> Self {
2231         ::std::convert::From::from(::std::clone::Clone::clone(value))
2232     }
2233 }
2234 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumMsmError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2235     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2236         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2237     }
2238 }
2239 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumMsmError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2240     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2241         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2242     }
2243 }
2244 #[repr(C)]
2245 #[doc(hidden)]
2246 pub struct IEnumMsmError_abi(
2247     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2248     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2249     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2250     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cfetch: u32, rgmsmerrors: *mut ::windows::runtime::RawPtr, pcfetched: *mut u32) -> ::windows::runtime::HRESULT,
2251     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cskip: u32) -> ::windows::runtime::HRESULT,
2252     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2253     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pemsmerrors: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2254 );
2255 #[repr(transparent)]
2256 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2257 pub struct IEnumMsmString(::windows::runtime::IUnknown);
2258 impl IEnumMsmString {
2259     #[cfg(feature = "Win32_Foundation")]
Next(&self, cfetch: u32, rgbstrstrings: *mut super::super::Foundation::BSTR, pcfetched: *mut u32) -> ::windows::runtime::Result<()>2260     pub unsafe fn Next(&self, cfetch: u32, rgbstrstrings: *mut super::super::Foundation::BSTR, pcfetched: *mut u32) -> ::windows::runtime::Result<()> {
2261         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(cfetch), ::std::mem::transmute(rgbstrstrings), ::std::mem::transmute(pcfetched)).ok()
2262     }
Skip(&self, cskip: u32) -> ::windows::runtime::Result<()>2263     pub unsafe fn Skip(&self, cskip: u32) -> ::windows::runtime::Result<()> {
2264         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cskip)).ok()
2265     }
Reset(&self) -> ::windows::runtime::Result<()>2266     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2267         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2268     }
Clone(&self) -> ::windows::runtime::Result<IEnumMsmString>2269     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumMsmString> {
2270         let mut result__: <IEnumMsmString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2271         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumMsmString>(result__)
2272     }
2273 }
2274 unsafe impl ::windows::runtime::Interface for IEnumMsmString {
2275     type Vtable = IEnumMsmString_abi;
2276     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298662, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2277 }
2278 impl ::std::convert::From<IEnumMsmString> for ::windows::runtime::IUnknown {
from(value: IEnumMsmString) -> Self2279     fn from(value: IEnumMsmString) -> Self {
2280         unsafe { ::std::mem::transmute(value) }
2281     }
2282 }
2283 impl ::std::convert::From<&IEnumMsmString> for ::windows::runtime::IUnknown {
from(value: &IEnumMsmString) -> Self2284     fn from(value: &IEnumMsmString) -> Self {
2285         ::std::convert::From::from(::std::clone::Clone::clone(value))
2286     }
2287 }
2288 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumMsmString {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2289     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2290         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2291     }
2292 }
2293 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumMsmString {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2294     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2295         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2296     }
2297 }
2298 #[repr(C)]
2299 #[doc(hidden)]
2300 pub struct IEnumMsmString_abi(
2301     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2302     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2303     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2304     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cfetch: u32, rgbstrstrings: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pcfetched: *mut u32) -> ::windows::runtime::HRESULT,
2305     #[cfg(not(feature = "Win32_Foundation"))] usize,
2306     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cskip: u32) -> ::windows::runtime::HRESULT,
2307     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2308     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pemsmstrings: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2309 );
2310 #[repr(transparent)]
2311 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2312 pub struct IMsmDependencies(::windows::runtime::IUnknown);
2313 impl IMsmDependencies {
Item(&self, item: i32) -> ::windows::runtime::Result<IMsmDependency>2314     pub unsafe fn Item(&self, item: i32) -> ::windows::runtime::Result<IMsmDependency> {
2315         let mut result__: <IMsmDependency as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2316         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(item), &mut result__).from_abi::<IMsmDependency>(result__)
2317     }
Count(&self, count: *mut i32) -> ::windows::runtime::Result<()>2318     pub unsafe fn Count(&self, count: *mut i32) -> ::windows::runtime::Result<()> {
2319         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(count)).ok()
2320     }
_NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown>2321     pub unsafe fn _NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown> {
2322         let mut result__: <::windows::runtime::IUnknown as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2323         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::IUnknown>(result__)
2324     }
2325 }
2326 unsafe impl ::windows::runtime::Interface for IMsmDependencies {
2327     type Vtable = IMsmDependencies_abi;
2328     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298669, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2329 }
2330 impl ::std::convert::From<IMsmDependencies> for ::windows::runtime::IUnknown {
from(value: IMsmDependencies) -> Self2331     fn from(value: IMsmDependencies) -> Self {
2332         unsafe { ::std::mem::transmute(value) }
2333     }
2334 }
2335 impl ::std::convert::From<&IMsmDependencies> for ::windows::runtime::IUnknown {
from(value: &IMsmDependencies) -> Self2336     fn from(value: &IMsmDependencies) -> Self {
2337         ::std::convert::From::from(::std::clone::Clone::clone(value))
2338     }
2339 }
2340 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmDependencies {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2341     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2342         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2343     }
2344 }
2345 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmDependencies {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2346     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2347         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2348     }
2349 }
2350 #[cfg(feature = "Win32_System_Ole_Automation")]
2351 impl ::std::convert::From<IMsmDependencies> for super::Ole::Automation::IDispatch {
from(value: IMsmDependencies) -> Self2352     fn from(value: IMsmDependencies) -> Self {
2353         unsafe { ::std::mem::transmute(value) }
2354     }
2355 }
2356 #[cfg(feature = "Win32_System_Ole_Automation")]
2357 impl ::std::convert::From<&IMsmDependencies> for super::Ole::Automation::IDispatch {
from(value: &IMsmDependencies) -> Self2358     fn from(value: &IMsmDependencies) -> Self {
2359         ::std::convert::From::from(::std::clone::Clone::clone(value))
2360     }
2361 }
2362 #[cfg(feature = "Win32_System_Ole_Automation")]
2363 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmDependencies {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2364     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2365         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2366     }
2367 }
2368 #[cfg(feature = "Win32_System_Ole_Automation")]
2369 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmDependencies {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2370     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2371         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2372     }
2373 }
2374 #[repr(C)]
2375 #[doc(hidden)]
2376 pub struct IMsmDependencies_abi(
2377     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2378     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2379     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2380     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2381     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2382     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2383     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2384     #[cfg(not(feature = "Win32_Foundation"))] usize,
2385     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2386     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2387     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2388     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, item: i32, r#return: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2389     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: *mut i32) -> ::windows::runtime::HRESULT,
2390     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, newenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2391 );
2392 #[repr(transparent)]
2393 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2394 pub struct IMsmDependency(::windows::runtime::IUnknown);
2395 impl IMsmDependency {
2396     #[cfg(feature = "Win32_Foundation")]
Module(&self, module: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2397     pub unsafe fn Module(&self, module: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2398         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(module)).ok()
2399     }
Language(&self, language: *mut i16) -> ::windows::runtime::Result<()>2400     pub unsafe fn Language(&self, language: *mut i16) -> ::windows::runtime::Result<()> {
2401         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(language)).ok()
2402     }
2403     #[cfg(feature = "Win32_Foundation")]
Version(&self, version: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2404     pub unsafe fn Version(&self, version: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2405         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(version)).ok()
2406     }
2407 }
2408 unsafe impl ::windows::runtime::Interface for IMsmDependency {
2409     type Vtable = IMsmDependency_abi;
2410     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298667, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2411 }
2412 impl ::std::convert::From<IMsmDependency> for ::windows::runtime::IUnknown {
from(value: IMsmDependency) -> Self2413     fn from(value: IMsmDependency) -> Self {
2414         unsafe { ::std::mem::transmute(value) }
2415     }
2416 }
2417 impl ::std::convert::From<&IMsmDependency> for ::windows::runtime::IUnknown {
from(value: &IMsmDependency) -> Self2418     fn from(value: &IMsmDependency) -> Self {
2419         ::std::convert::From::from(::std::clone::Clone::clone(value))
2420     }
2421 }
2422 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2423     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2424         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2425     }
2426 }
2427 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2428     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2429         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2430     }
2431 }
2432 #[cfg(feature = "Win32_System_Ole_Automation")]
2433 impl ::std::convert::From<IMsmDependency> for super::Ole::Automation::IDispatch {
from(value: IMsmDependency) -> Self2434     fn from(value: IMsmDependency) -> Self {
2435         unsafe { ::std::mem::transmute(value) }
2436     }
2437 }
2438 #[cfg(feature = "Win32_System_Ole_Automation")]
2439 impl ::std::convert::From<&IMsmDependency> for super::Ole::Automation::IDispatch {
from(value: &IMsmDependency) -> Self2440     fn from(value: &IMsmDependency) -> Self {
2441         ::std::convert::From::from(::std::clone::Clone::clone(value))
2442     }
2443 }
2444 #[cfg(feature = "Win32_System_Ole_Automation")]
2445 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2446     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2447         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2448     }
2449 }
2450 #[cfg(feature = "Win32_System_Ole_Automation")]
2451 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmDependency {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2452     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2453         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2454     }
2455 }
2456 #[repr(C)]
2457 #[doc(hidden)]
2458 pub struct IMsmDependency_abi(
2459     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2460     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2461     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2462     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2463     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2464     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2465     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2466     #[cfg(not(feature = "Win32_Foundation"))] usize,
2467     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2468     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2469     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2470     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, module: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2471     #[cfg(not(feature = "Win32_Foundation"))] usize,
2472     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, language: *mut i16) -> ::windows::runtime::HRESULT,
2473     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, version: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2474     #[cfg(not(feature = "Win32_Foundation"))] usize,
2475 );
2476 #[repr(transparent)]
2477 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2478 pub struct IMsmError(::windows::runtime::IUnknown);
2479 impl IMsmError {
Type(&self, errortype: *mut msmErrorType) -> ::windows::runtime::Result<()>2480     pub unsafe fn Type(&self, errortype: *mut msmErrorType) -> ::windows::runtime::Result<()> {
2481         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(errortype)).ok()
2482     }
2483     #[cfg(feature = "Win32_Foundation")]
Path(&self, errorpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2484     pub unsafe fn Path(&self, errorpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2485         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(errorpath)).ok()
2486     }
Language(&self, errorlanguage: *mut i16) -> ::windows::runtime::Result<()>2487     pub unsafe fn Language(&self, errorlanguage: *mut i16) -> ::windows::runtime::Result<()> {
2488         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(errorlanguage)).ok()
2489     }
2490     #[cfg(feature = "Win32_Foundation")]
DatabaseTable(&self, errortable: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2491     pub unsafe fn DatabaseTable(&self, errortable: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2492         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(errortable)).ok()
2493     }
DatabaseKeys(&self) -> ::windows::runtime::Result<IMsmStrings>2494     pub unsafe fn DatabaseKeys(&self) -> ::windows::runtime::Result<IMsmStrings> {
2495         let mut result__: <IMsmStrings as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2496         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IMsmStrings>(result__)
2497     }
2498     #[cfg(feature = "Win32_Foundation")]
ModuleTable(&self, errortable: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2499     pub unsafe fn ModuleTable(&self, errortable: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2500         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(errortable)).ok()
2501     }
ModuleKeys(&self) -> ::windows::runtime::Result<IMsmStrings>2502     pub unsafe fn ModuleKeys(&self) -> ::windows::runtime::Result<IMsmStrings> {
2503         let mut result__: <IMsmStrings as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2504         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IMsmStrings>(result__)
2505     }
2506 }
2507 unsafe impl ::windows::runtime::Interface for IMsmError {
2508     type Vtable = IMsmError_abi;
2509     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298664, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2510 }
2511 impl ::std::convert::From<IMsmError> for ::windows::runtime::IUnknown {
from(value: IMsmError) -> Self2512     fn from(value: IMsmError) -> Self {
2513         unsafe { ::std::mem::transmute(value) }
2514     }
2515 }
2516 impl ::std::convert::From<&IMsmError> for ::windows::runtime::IUnknown {
from(value: &IMsmError) -> Self2517     fn from(value: &IMsmError) -> Self {
2518         ::std::convert::From::from(::std::clone::Clone::clone(value))
2519     }
2520 }
2521 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2522     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2523         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2524     }
2525 }
2526 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2527     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2528         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2529     }
2530 }
2531 #[cfg(feature = "Win32_System_Ole_Automation")]
2532 impl ::std::convert::From<IMsmError> for super::Ole::Automation::IDispatch {
from(value: IMsmError) -> Self2533     fn from(value: IMsmError) -> Self {
2534         unsafe { ::std::mem::transmute(value) }
2535     }
2536 }
2537 #[cfg(feature = "Win32_System_Ole_Automation")]
2538 impl ::std::convert::From<&IMsmError> for super::Ole::Automation::IDispatch {
from(value: &IMsmError) -> Self2539     fn from(value: &IMsmError) -> Self {
2540         ::std::convert::From::from(::std::clone::Clone::clone(value))
2541     }
2542 }
2543 #[cfg(feature = "Win32_System_Ole_Automation")]
2544 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmError {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2545     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2546         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2547     }
2548 }
2549 #[cfg(feature = "Win32_System_Ole_Automation")]
2550 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmError {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2551     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2552         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2553     }
2554 }
2555 #[repr(C)]
2556 #[doc(hidden)]
2557 pub struct IMsmError_abi(
2558     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2559     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2560     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2561     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2562     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2563     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2564     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2565     #[cfg(not(feature = "Win32_Foundation"))] usize,
2566     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2567     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2568     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2569     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errortype: *mut msmErrorType) -> ::windows::runtime::HRESULT,
2570     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errorpath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2571     #[cfg(not(feature = "Win32_Foundation"))] usize,
2572     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errorlanguage: *mut i16) -> ::windows::runtime::HRESULT,
2573     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errortable: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2574     #[cfg(not(feature = "Win32_Foundation"))] usize,
2575     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errorkeys: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2576     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errortable: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2577     #[cfg(not(feature = "Win32_Foundation"))] usize,
2578     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errorkeys: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2579 );
2580 #[repr(transparent)]
2581 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2582 pub struct IMsmErrors(::windows::runtime::IUnknown);
2583 impl IMsmErrors {
Item(&self, item: i32) -> ::windows::runtime::Result<IMsmError>2584     pub unsafe fn Item(&self, item: i32) -> ::windows::runtime::Result<IMsmError> {
2585         let mut result__: <IMsmError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2586         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(item), &mut result__).from_abi::<IMsmError>(result__)
2587     }
Count(&self, count: *mut i32) -> ::windows::runtime::Result<()>2588     pub unsafe fn Count(&self, count: *mut i32) -> ::windows::runtime::Result<()> {
2589         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(count)).ok()
2590     }
_NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown>2591     pub unsafe fn _NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown> {
2592         let mut result__: <::windows::runtime::IUnknown as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2593         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::IUnknown>(result__)
2594     }
2595 }
2596 unsafe impl ::windows::runtime::Interface for IMsmErrors {
2597     type Vtable = IMsmErrors_abi;
2598     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298666, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2599 }
2600 impl ::std::convert::From<IMsmErrors> for ::windows::runtime::IUnknown {
from(value: IMsmErrors) -> Self2601     fn from(value: IMsmErrors) -> Self {
2602         unsafe { ::std::mem::transmute(value) }
2603     }
2604 }
2605 impl ::std::convert::From<&IMsmErrors> for ::windows::runtime::IUnknown {
from(value: &IMsmErrors) -> Self2606     fn from(value: &IMsmErrors) -> Self {
2607         ::std::convert::From::from(::std::clone::Clone::clone(value))
2608     }
2609 }
2610 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmErrors {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2611     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2612         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2613     }
2614 }
2615 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmErrors {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2616     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2617         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2618     }
2619 }
2620 #[cfg(feature = "Win32_System_Ole_Automation")]
2621 impl ::std::convert::From<IMsmErrors> for super::Ole::Automation::IDispatch {
from(value: IMsmErrors) -> Self2622     fn from(value: IMsmErrors) -> Self {
2623         unsafe { ::std::mem::transmute(value) }
2624     }
2625 }
2626 #[cfg(feature = "Win32_System_Ole_Automation")]
2627 impl ::std::convert::From<&IMsmErrors> for super::Ole::Automation::IDispatch {
from(value: &IMsmErrors) -> Self2628     fn from(value: &IMsmErrors) -> Self {
2629         ::std::convert::From::from(::std::clone::Clone::clone(value))
2630     }
2631 }
2632 #[cfg(feature = "Win32_System_Ole_Automation")]
2633 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmErrors {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2634     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2635         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2636     }
2637 }
2638 #[cfg(feature = "Win32_System_Ole_Automation")]
2639 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmErrors {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2640     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2641         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2642     }
2643 }
2644 #[repr(C)]
2645 #[doc(hidden)]
2646 pub struct IMsmErrors_abi(
2647     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2648     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2649     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2650     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2651     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2652     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2653     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2654     #[cfg(not(feature = "Win32_Foundation"))] usize,
2655     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2656     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2657     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2658     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, item: i32, r#return: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2659     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: *mut i32) -> ::windows::runtime::HRESULT,
2660     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, newenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2661 );
2662 #[repr(transparent)]
2663 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2664 pub struct IMsmGetFiles(::windows::runtime::IUnknown);
2665 impl IMsmGetFiles {
ModuleFiles(&self) -> ::windows::runtime::Result<IMsmStrings>2666     pub unsafe fn ModuleFiles(&self) -> ::windows::runtime::Result<IMsmStrings> {
2667         let mut result__: <IMsmStrings as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2668         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IMsmStrings>(result__)
2669     }
2670 }
2671 unsafe impl ::windows::runtime::Interface for IMsmGetFiles {
2672     type Vtable = IMsmGetFiles_abi;
2673     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1883352614, 11640, 4562, [136, 138, 0, 160, 201, 129, 176, 21]);
2674 }
2675 impl ::std::convert::From<IMsmGetFiles> for ::windows::runtime::IUnknown {
from(value: IMsmGetFiles) -> Self2676     fn from(value: IMsmGetFiles) -> Self {
2677         unsafe { ::std::mem::transmute(value) }
2678     }
2679 }
2680 impl ::std::convert::From<&IMsmGetFiles> for ::windows::runtime::IUnknown {
from(value: &IMsmGetFiles) -> Self2681     fn from(value: &IMsmGetFiles) -> Self {
2682         ::std::convert::From::from(::std::clone::Clone::clone(value))
2683     }
2684 }
2685 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmGetFiles {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2686     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2687         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2688     }
2689 }
2690 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmGetFiles {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2691     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2692         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2693     }
2694 }
2695 #[cfg(feature = "Win32_System_Ole_Automation")]
2696 impl ::std::convert::From<IMsmGetFiles> for super::Ole::Automation::IDispatch {
from(value: IMsmGetFiles) -> Self2697     fn from(value: IMsmGetFiles) -> Self {
2698         unsafe { ::std::mem::transmute(value) }
2699     }
2700 }
2701 #[cfg(feature = "Win32_System_Ole_Automation")]
2702 impl ::std::convert::From<&IMsmGetFiles> for super::Ole::Automation::IDispatch {
from(value: &IMsmGetFiles) -> Self2703     fn from(value: &IMsmGetFiles) -> Self {
2704         ::std::convert::From::from(::std::clone::Clone::clone(value))
2705     }
2706 }
2707 #[cfg(feature = "Win32_System_Ole_Automation")]
2708 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmGetFiles {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2709     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2710         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2711     }
2712 }
2713 #[cfg(feature = "Win32_System_Ole_Automation")]
2714 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmGetFiles {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2715     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2716         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2717     }
2718 }
2719 #[repr(C)]
2720 #[doc(hidden)]
2721 pub struct IMsmGetFiles_abi(
2722     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2723     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2724     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2725     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2726     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2727     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2728     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2729     #[cfg(not(feature = "Win32_Foundation"))] usize,
2730     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2731     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2732     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2733     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, files: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2734 );
2735 #[repr(transparent)]
2736 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2737 pub struct IMsmMerge(::windows::runtime::IUnknown);
2738 impl IMsmMerge {
2739     #[cfg(feature = "Win32_Foundation")]
OpenDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()>2740     pub unsafe fn OpenDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()> {
2741         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), path.into_param().abi()).ok()
2742     }
2743     #[cfg(feature = "Win32_Foundation")]
OpenModule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0, language: i16) -> ::windows::runtime::Result<()>2744     pub unsafe fn OpenModule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0, language: i16) -> ::windows::runtime::Result<()> {
2745         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), path.into_param().abi(), ::std::mem::transmute(language)).ok()
2746     }
CloseDatabase(&self, commit: i16) -> ::windows::runtime::Result<()>2747     pub unsafe fn CloseDatabase(&self, commit: i16) -> ::windows::runtime::Result<()> {
2748         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(commit)).ok()
2749     }
CloseModule(&self) -> ::windows::runtime::Result<()>2750     pub unsafe fn CloseModule(&self) -> ::windows::runtime::Result<()> {
2751         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self)).ok()
2752     }
2753     #[cfg(feature = "Win32_Foundation")]
OpenLog<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()>2754     pub unsafe fn OpenLog<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()> {
2755         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), path.into_param().abi()).ok()
2756     }
CloseLog(&self) -> ::windows::runtime::Result<()>2757     pub unsafe fn CloseLog(&self) -> ::windows::runtime::Result<()> {
2758         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self)).ok()
2759     }
2760     #[cfg(feature = "Win32_Foundation")]
Log<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, message: Param0) -> ::windows::runtime::Result<()>2761     pub unsafe fn Log<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, message: Param0) -> ::windows::runtime::Result<()> {
2762         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), message.into_param().abi()).ok()
2763     }
Errors(&self) -> ::windows::runtime::Result<IMsmErrors>2764     pub unsafe fn Errors(&self) -> ::windows::runtime::Result<IMsmErrors> {
2765         let mut result__: <IMsmErrors as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2766         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IMsmErrors>(result__)
2767     }
Dependencies(&self) -> ::windows::runtime::Result<IMsmDependencies>2768     pub unsafe fn Dependencies(&self) -> ::windows::runtime::Result<IMsmDependencies> {
2769         let mut result__: <IMsmDependencies as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2770         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IMsmDependencies>(result__)
2771     }
2772     #[cfg(feature = "Win32_Foundation")]
Merge<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feature: Param0, redirectdir: Param1) -> ::windows::runtime::Result<()>2773     pub unsafe fn Merge<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feature: Param0, redirectdir: Param1) -> ::windows::runtime::Result<()> {
2774         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), feature.into_param().abi(), redirectdir.into_param().abi()).ok()
2775     }
2776     #[cfg(feature = "Win32_Foundation")]
Connect<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feature: Param0) -> ::windows::runtime::Result<()>2777     pub unsafe fn Connect<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feature: Param0) -> ::windows::runtime::Result<()> {
2778         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), feature.into_param().abi()).ok()
2779     }
2780     #[cfg(feature = "Win32_Foundation")]
ExtractCAB<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filename: Param0) -> ::windows::runtime::Result<()>2781     pub unsafe fn ExtractCAB<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filename: Param0) -> ::windows::runtime::Result<()> {
2782         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), filename.into_param().abi()).ok()
2783     }
2784     #[cfg(feature = "Win32_Foundation")]
ExtractFiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()>2785     pub unsafe fn ExtractFiles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, path: Param0) -> ::windows::runtime::Result<()> {
2786         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), path.into_param().abi()).ok()
2787     }
2788 }
2789 unsafe impl ::windows::runtime::Interface for IMsmMerge {
2790     type Vtable = IMsmMerge_abi;
2791     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298670, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2792 }
2793 impl ::std::convert::From<IMsmMerge> for ::windows::runtime::IUnknown {
from(value: IMsmMerge) -> Self2794     fn from(value: IMsmMerge) -> Self {
2795         unsafe { ::std::mem::transmute(value) }
2796     }
2797 }
2798 impl ::std::convert::From<&IMsmMerge> for ::windows::runtime::IUnknown {
from(value: &IMsmMerge) -> Self2799     fn from(value: &IMsmMerge) -> Self {
2800         ::std::convert::From::from(::std::clone::Clone::clone(value))
2801     }
2802 }
2803 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmMerge {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2804     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2805         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2806     }
2807 }
2808 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmMerge {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2809     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2810         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2811     }
2812 }
2813 #[cfg(feature = "Win32_System_Ole_Automation")]
2814 impl ::std::convert::From<IMsmMerge> for super::Ole::Automation::IDispatch {
from(value: IMsmMerge) -> Self2815     fn from(value: IMsmMerge) -> Self {
2816         unsafe { ::std::mem::transmute(value) }
2817     }
2818 }
2819 #[cfg(feature = "Win32_System_Ole_Automation")]
2820 impl ::std::convert::From<&IMsmMerge> for super::Ole::Automation::IDispatch {
from(value: &IMsmMerge) -> Self2821     fn from(value: &IMsmMerge) -> Self {
2822         ::std::convert::From::from(::std::clone::Clone::clone(value))
2823     }
2824 }
2825 #[cfg(feature = "Win32_System_Ole_Automation")]
2826 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmMerge {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2827     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2828         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2829     }
2830 }
2831 #[cfg(feature = "Win32_System_Ole_Automation")]
2832 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmMerge {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2833     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2834         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2835     }
2836 }
2837 #[repr(C)]
2838 #[doc(hidden)]
2839 pub struct IMsmMerge_abi(
2840     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2841     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2842     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2843     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2844     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2845     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2846     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2847     #[cfg(not(feature = "Win32_Foundation"))] usize,
2848     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2849     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2850     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2851     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, path: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2852     #[cfg(not(feature = "Win32_Foundation"))] usize,
2853     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, path: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, language: i16) -> ::windows::runtime::HRESULT,
2854     #[cfg(not(feature = "Win32_Foundation"))] usize,
2855     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, commit: i16) -> ::windows::runtime::HRESULT,
2856     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2857     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, path: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2858     #[cfg(not(feature = "Win32_Foundation"))] usize,
2859     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2860     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, message: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2861     #[cfg(not(feature = "Win32_Foundation"))] usize,
2862     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, errors: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2863     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dependencies: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2864     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, feature: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, redirectdir: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2865     #[cfg(not(feature = "Win32_Foundation"))] usize,
2866     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, feature: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2867     #[cfg(not(feature = "Win32_Foundation"))] usize,
2868     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, filename: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2869     #[cfg(not(feature = "Win32_Foundation"))] usize,
2870     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, path: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2871     #[cfg(not(feature = "Win32_Foundation"))] usize,
2872 );
2873 #[repr(transparent)]
2874 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2875 pub struct IMsmStrings(::windows::runtime::IUnknown);
2876 impl IMsmStrings {
2877     #[cfg(feature = "Win32_Foundation")]
Item(&self, item: i32, r#return: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>2878     pub unsafe fn Item(&self, item: i32, r#return: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
2879         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(item), ::std::mem::transmute(r#return)).ok()
2880     }
Count(&self, count: *mut i32) -> ::windows::runtime::Result<()>2881     pub unsafe fn Count(&self, count: *mut i32) -> ::windows::runtime::Result<()> {
2882         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(count)).ok()
2883     }
_NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown>2884     pub unsafe fn _NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown> {
2885         let mut result__: <::windows::runtime::IUnknown as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2886         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::IUnknown>(result__)
2887     }
2888 }
2889 unsafe impl ::windows::runtime::Interface for IMsmStrings {
2890     type Vtable = IMsmStrings_abi;
2891     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298663, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
2892 }
2893 impl ::std::convert::From<IMsmStrings> for ::windows::runtime::IUnknown {
from(value: IMsmStrings) -> Self2894     fn from(value: IMsmStrings) -> Self {
2895         unsafe { ::std::mem::transmute(value) }
2896     }
2897 }
2898 impl ::std::convert::From<&IMsmStrings> for ::windows::runtime::IUnknown {
from(value: &IMsmStrings) -> Self2899     fn from(value: &IMsmStrings) -> Self {
2900         ::std::convert::From::from(::std::clone::Clone::clone(value))
2901     }
2902 }
2903 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMsmStrings {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2904     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2905         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2906     }
2907 }
2908 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMsmStrings {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2909     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2910         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2911     }
2912 }
2913 #[cfg(feature = "Win32_System_Ole_Automation")]
2914 impl ::std::convert::From<IMsmStrings> for super::Ole::Automation::IDispatch {
from(value: IMsmStrings) -> Self2915     fn from(value: IMsmStrings) -> Self {
2916         unsafe { ::std::mem::transmute(value) }
2917     }
2918 }
2919 #[cfg(feature = "Win32_System_Ole_Automation")]
2920 impl ::std::convert::From<&IMsmStrings> for super::Ole::Automation::IDispatch {
from(value: &IMsmStrings) -> Self2921     fn from(value: &IMsmStrings) -> Self {
2922         ::std::convert::From::from(::std::clone::Clone::clone(value))
2923     }
2924 }
2925 #[cfg(feature = "Win32_System_Ole_Automation")]
2926 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for IMsmStrings {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2927     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2928         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(self))
2929     }
2930 }
2931 #[cfg(feature = "Win32_System_Ole_Automation")]
2932 impl<'a> ::windows::runtime::IntoParam<'a, super::Ole::Automation::IDispatch> for &IMsmStrings {
into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch>2933     fn into_param(self) -> ::windows::runtime::Param<'a, super::Ole::Automation::IDispatch> {
2934         ::windows::runtime::Param::Owned(::std::convert::Into::<super::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
2935     }
2936 }
2937 #[repr(C)]
2938 #[doc(hidden)]
2939 pub struct IMsmStrings_abi(
2940     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2941     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2942     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2943     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
2944     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2945     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
2946     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
2947     #[cfg(not(feature = "Win32_Foundation"))] usize,
2948     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
2949     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
2950     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
2951     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, item: i32, r#return: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
2952     #[cfg(not(feature = "Win32_Foundation"))] usize,
2953     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: *mut i32) -> ::windows::runtime::HRESULT,
2954     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, newenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2955 );
2956 pub const INFO_BASE: u32 = 3222229249u32;
2957 pub const INFO_ENTERING_PHASE_I: u32 = 3222229251u32;
2958 pub const INFO_ENTERING_PHASE_II: u32 = 3222229256u32;
2959 pub const INFO_ENTERING_PHASE_III: u32 = 3222229257u32;
2960 pub const INFO_ENTERING_PHASE_IV: u32 = 3222229258u32;
2961 pub const INFO_ENTERING_PHASE_I_VALIDATION: u32 = 3222229250u32;
2962 pub const INFO_ENTERING_PHASE_V: u32 = 3222229259u32;
2963 pub const INFO_GENERATING_METADATA: u32 = 3222229265u32;
2964 pub const INFO_PASSED_MAIN_CONTROL: u32 = 3222229249u32;
2965 pub const INFO_PATCHCACHE_FILEINFO_FAILURE: u32 = 3222229267u32;
2966 pub const INFO_PATCHCACHE_PCI_READFAILURE: u32 = 3222229268u32;
2967 pub const INFO_PATCHCACHE_PCI_WRITEFAILURE: u32 = 3222229269u32;
2968 pub const INFO_PCP_PATH: u32 = 3222229252u32;
2969 pub const INFO_PROPERTY: u32 = 3222229255u32;
2970 pub const INFO_SET_OPTIONS: u32 = 3222229254u32;
2971 pub const INFO_SUCCESSFUL_PATCH_CREATION: u32 = 3222229271u32;
2972 pub const INFO_TEMP_DIR: u32 = 3222229253u32;
2973 pub const INFO_TEMP_DIR_CLEANUP: u32 = 3222229266u32;
2974 pub const INFO_USING_USER_MSI_FOR_PATCH_TABLES: u32 = 3222229270u32;
2975 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2976 #[repr(transparent)]
2977 pub struct INSTALLFEATUREATTRIBUTE(pub i32);
2978 pub const INSTALLFEATUREATTRIBUTE_FAVORLOCAL: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(1i32);
2979 pub const INSTALLFEATUREATTRIBUTE_FAVORSOURCE: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(2i32);
2980 pub const INSTALLFEATUREATTRIBUTE_FOLLOWPARENT: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(4i32);
2981 pub const INSTALLFEATUREATTRIBUTE_FAVORADVERTISE: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(8i32);
2982 pub const INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(16i32);
2983 pub const INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE: INSTALLFEATUREATTRIBUTE = INSTALLFEATUREATTRIBUTE(32i32);
2984 impl ::std::convert::From<i32> for INSTALLFEATUREATTRIBUTE {
from(value: i32) -> Self2985     fn from(value: i32) -> Self {
2986         Self(value)
2987     }
2988 }
2989 unsafe impl ::windows::runtime::Abi for INSTALLFEATUREATTRIBUTE {
2990     type Abi = Self;
2991     type DefaultType = Self;
2992 }
2993 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2994 #[repr(transparent)]
2995 pub struct INSTALLLEVEL(pub i32);
2996 pub const INSTALLLEVEL_DEFAULT: INSTALLLEVEL = INSTALLLEVEL(0i32);
2997 pub const INSTALLLEVEL_MINIMUM: INSTALLLEVEL = INSTALLLEVEL(1i32);
2998 pub const INSTALLLEVEL_MAXIMUM: INSTALLLEVEL = INSTALLLEVEL(65535i32);
2999 impl ::std::convert::From<i32> for INSTALLLEVEL {
from(value: i32) -> Self3000     fn from(value: i32) -> Self {
3001         Self(value)
3002     }
3003 }
3004 unsafe impl ::windows::runtime::Abi for INSTALLLEVEL {
3005     type Abi = Self;
3006     type DefaultType = Self;
3007 }
3008 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3009 #[repr(transparent)]
3010 pub struct INSTALLLOGATTRIBUTES(pub i32);
3011 pub const INSTALLLOGATTRIBUTES_APPEND: INSTALLLOGATTRIBUTES = INSTALLLOGATTRIBUTES(1i32);
3012 pub const INSTALLLOGATTRIBUTES_FLUSHEACHLINE: INSTALLLOGATTRIBUTES = INSTALLLOGATTRIBUTES(2i32);
3013 impl ::std::convert::From<i32> for INSTALLLOGATTRIBUTES {
from(value: i32) -> Self3014     fn from(value: i32) -> Self {
3015         Self(value)
3016     }
3017 }
3018 unsafe impl ::windows::runtime::Abi for INSTALLLOGATTRIBUTES {
3019     type Abi = Self;
3020     type DefaultType = Self;
3021 }
3022 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3023 #[repr(transparent)]
3024 pub struct INSTALLMESSAGE(pub i32);
3025 pub const INSTALLMESSAGE_FATALEXIT: INSTALLMESSAGE = INSTALLMESSAGE(0i32);
3026 pub const INSTALLMESSAGE_ERROR: INSTALLMESSAGE = INSTALLMESSAGE(16777216i32);
3027 pub const INSTALLMESSAGE_WARNING: INSTALLMESSAGE = INSTALLMESSAGE(33554432i32);
3028 pub const INSTALLMESSAGE_USER: INSTALLMESSAGE = INSTALLMESSAGE(50331648i32);
3029 pub const INSTALLMESSAGE_INFO: INSTALLMESSAGE = INSTALLMESSAGE(67108864i32);
3030 pub const INSTALLMESSAGE_FILESINUSE: INSTALLMESSAGE = INSTALLMESSAGE(83886080i32);
3031 pub const INSTALLMESSAGE_RESOLVESOURCE: INSTALLMESSAGE = INSTALLMESSAGE(100663296i32);
3032 pub const INSTALLMESSAGE_OUTOFDISKSPACE: INSTALLMESSAGE = INSTALLMESSAGE(117440512i32);
3033 pub const INSTALLMESSAGE_ACTIONSTART: INSTALLMESSAGE = INSTALLMESSAGE(134217728i32);
3034 pub const INSTALLMESSAGE_ACTIONDATA: INSTALLMESSAGE = INSTALLMESSAGE(150994944i32);
3035 pub const INSTALLMESSAGE_PROGRESS: INSTALLMESSAGE = INSTALLMESSAGE(167772160i32);
3036 pub const INSTALLMESSAGE_COMMONDATA: INSTALLMESSAGE = INSTALLMESSAGE(184549376i32);
3037 pub const INSTALLMESSAGE_INITIALIZE: INSTALLMESSAGE = INSTALLMESSAGE(201326592i32);
3038 pub const INSTALLMESSAGE_TERMINATE: INSTALLMESSAGE = INSTALLMESSAGE(218103808i32);
3039 pub const INSTALLMESSAGE_SHOWDIALOG: INSTALLMESSAGE = INSTALLMESSAGE(234881024i32);
3040 pub const INSTALLMESSAGE_PERFORMANCE: INSTALLMESSAGE = INSTALLMESSAGE(251658240i32);
3041 pub const INSTALLMESSAGE_RMFILESINUSE: INSTALLMESSAGE = INSTALLMESSAGE(419430400i32);
3042 pub const INSTALLMESSAGE_INSTALLSTART: INSTALLMESSAGE = INSTALLMESSAGE(436207616i32);
3043 pub const INSTALLMESSAGE_INSTALLEND: INSTALLMESSAGE = INSTALLMESSAGE(452984832i32);
3044 impl ::std::convert::From<i32> for INSTALLMESSAGE {
from(value: i32) -> Self3045     fn from(value: i32) -> Self {
3046         Self(value)
3047     }
3048 }
3049 unsafe impl ::windows::runtime::Abi for INSTALLMESSAGE {
3050     type Abi = Self;
3051     type DefaultType = Self;
3052 }
3053 pub const INSTALLMESSAGE_TYPEMASK: i32 = -16777216i32;
3054 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3055 #[repr(transparent)]
3056 pub struct INSTALLMODE(pub i32);
3057 pub const INSTALLMODE_NODETECTION_ANY: INSTALLMODE = INSTALLMODE(-4i32);
3058 pub const INSTALLMODE_NOSOURCERESOLUTION: INSTALLMODE = INSTALLMODE(-3i32);
3059 pub const INSTALLMODE_NODETECTION: INSTALLMODE = INSTALLMODE(-2i32);
3060 pub const INSTALLMODE_EXISTING: INSTALLMODE = INSTALLMODE(-1i32);
3061 pub const INSTALLMODE_DEFAULT: INSTALLMODE = INSTALLMODE(0i32);
3062 impl ::std::convert::From<i32> for INSTALLMODE {
from(value: i32) -> Self3063     fn from(value: i32) -> Self {
3064         Self(value)
3065     }
3066 }
3067 unsafe impl ::windows::runtime::Abi for INSTALLMODE {
3068     type Abi = Self;
3069     type DefaultType = Self;
3070 }
3071 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3072 #[repr(transparent)]
3073 pub struct INSTALLOGMODE(pub i32);
3074 pub const INSTALLLOGMODE_FATALEXIT: INSTALLOGMODE = INSTALLOGMODE(1i32);
3075 pub const INSTALLLOGMODE_ERROR: INSTALLOGMODE = INSTALLOGMODE(2i32);
3076 pub const INSTALLLOGMODE_WARNING: INSTALLOGMODE = INSTALLOGMODE(4i32);
3077 pub const INSTALLLOGMODE_USER: INSTALLOGMODE = INSTALLOGMODE(8i32);
3078 pub const INSTALLLOGMODE_INFO: INSTALLOGMODE = INSTALLOGMODE(16i32);
3079 pub const INSTALLLOGMODE_RESOLVESOURCE: INSTALLOGMODE = INSTALLOGMODE(64i32);
3080 pub const INSTALLLOGMODE_OUTOFDISKSPACE: INSTALLOGMODE = INSTALLOGMODE(128i32);
3081 pub const INSTALLLOGMODE_ACTIONSTART: INSTALLOGMODE = INSTALLOGMODE(256i32);
3082 pub const INSTALLLOGMODE_ACTIONDATA: INSTALLOGMODE = INSTALLOGMODE(512i32);
3083 pub const INSTALLLOGMODE_COMMONDATA: INSTALLOGMODE = INSTALLOGMODE(2048i32);
3084 pub const INSTALLLOGMODE_PROPERTYDUMP: INSTALLOGMODE = INSTALLOGMODE(1024i32);
3085 pub const INSTALLLOGMODE_VERBOSE: INSTALLOGMODE = INSTALLOGMODE(4096i32);
3086 pub const INSTALLLOGMODE_EXTRADEBUG: INSTALLOGMODE = INSTALLOGMODE(8192i32);
3087 pub const INSTALLLOGMODE_LOGONLYONERROR: INSTALLOGMODE = INSTALLOGMODE(16384i32);
3088 pub const INSTALLLOGMODE_LOGPERFORMANCE: INSTALLOGMODE = INSTALLOGMODE(32768i32);
3089 pub const INSTALLLOGMODE_PROGRESS: INSTALLOGMODE = INSTALLOGMODE(1024i32);
3090 pub const INSTALLLOGMODE_INITIALIZE: INSTALLOGMODE = INSTALLOGMODE(4096i32);
3091 pub const INSTALLLOGMODE_TERMINATE: INSTALLOGMODE = INSTALLOGMODE(8192i32);
3092 pub const INSTALLLOGMODE_SHOWDIALOG: INSTALLOGMODE = INSTALLOGMODE(16384i32);
3093 pub const INSTALLLOGMODE_FILESINUSE: INSTALLOGMODE = INSTALLOGMODE(32i32);
3094 pub const INSTALLLOGMODE_RMFILESINUSE: INSTALLOGMODE = INSTALLOGMODE(33554432i32);
3095 pub const INSTALLLOGMODE_INSTALLSTART: INSTALLOGMODE = INSTALLOGMODE(67108864i32);
3096 pub const INSTALLLOGMODE_INSTALLEND: INSTALLOGMODE = INSTALLOGMODE(134217728i32);
3097 impl ::std::convert::From<i32> for INSTALLOGMODE {
from(value: i32) -> Self3098     fn from(value: i32) -> Self {
3099         Self(value)
3100     }
3101 }
3102 unsafe impl ::windows::runtime::Abi for INSTALLOGMODE {
3103     type Abi = Self;
3104     type DefaultType = Self;
3105 }
3106 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3107 #[repr(transparent)]
3108 pub struct INSTALLSTATE(pub i32);
3109 pub const INSTALLSTATE_NOTUSED: INSTALLSTATE = INSTALLSTATE(-7i32);
3110 pub const INSTALLSTATE_BADCONFIG: INSTALLSTATE = INSTALLSTATE(-6i32);
3111 pub const INSTALLSTATE_INCOMPLETE: INSTALLSTATE = INSTALLSTATE(-5i32);
3112 pub const INSTALLSTATE_SOURCEABSENT: INSTALLSTATE = INSTALLSTATE(-4i32);
3113 pub const INSTALLSTATE_MOREDATA: INSTALLSTATE = INSTALLSTATE(-3i32);
3114 pub const INSTALLSTATE_INVALIDARG: INSTALLSTATE = INSTALLSTATE(-2i32);
3115 pub const INSTALLSTATE_UNKNOWN: INSTALLSTATE = INSTALLSTATE(-1i32);
3116 pub const INSTALLSTATE_BROKEN: INSTALLSTATE = INSTALLSTATE(0i32);
3117 pub const INSTALLSTATE_ADVERTISED: INSTALLSTATE = INSTALLSTATE(1i32);
3118 pub const INSTALLSTATE_REMOVED: INSTALLSTATE = INSTALLSTATE(1i32);
3119 pub const INSTALLSTATE_ABSENT: INSTALLSTATE = INSTALLSTATE(2i32);
3120 pub const INSTALLSTATE_LOCAL: INSTALLSTATE = INSTALLSTATE(3i32);
3121 pub const INSTALLSTATE_SOURCE: INSTALLSTATE = INSTALLSTATE(4i32);
3122 pub const INSTALLSTATE_DEFAULT: INSTALLSTATE = INSTALLSTATE(5i32);
3123 impl ::std::convert::From<i32> for INSTALLSTATE {
from(value: i32) -> Self3124     fn from(value: i32) -> Self {
3125         Self(value)
3126     }
3127 }
3128 unsafe impl ::windows::runtime::Abi for INSTALLSTATE {
3129     type Abi = Self;
3130     type DefaultType = Self;
3131 }
3132 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3133 #[repr(transparent)]
3134 pub struct INSTALLTYPE(pub i32);
3135 pub const INSTALLTYPE_DEFAULT: INSTALLTYPE = INSTALLTYPE(0i32);
3136 pub const INSTALLTYPE_NETWORK_IMAGE: INSTALLTYPE = INSTALLTYPE(1i32);
3137 pub const INSTALLTYPE_SINGLE_INSTANCE: INSTALLTYPE = INSTALLTYPE(2i32);
3138 impl ::std::convert::From<i32> for INSTALLTYPE {
from(value: i32) -> Self3139     fn from(value: i32) -> Self {
3140         Self(value)
3141     }
3142 }
3143 unsafe impl ::windows::runtime::Abi for INSTALLTYPE {
3144     type Abi = Self;
3145     type DefaultType = Self;
3146 }
3147 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3148 #[repr(transparent)]
3149 pub struct INSTALLUILEVEL(pub i32);
3150 pub const INSTALLUILEVEL_NOCHANGE: INSTALLUILEVEL = INSTALLUILEVEL(0i32);
3151 pub const INSTALLUILEVEL_DEFAULT: INSTALLUILEVEL = INSTALLUILEVEL(1i32);
3152 pub const INSTALLUILEVEL_NONE: INSTALLUILEVEL = INSTALLUILEVEL(2i32);
3153 pub const INSTALLUILEVEL_BASIC: INSTALLUILEVEL = INSTALLUILEVEL(3i32);
3154 pub const INSTALLUILEVEL_REDUCED: INSTALLUILEVEL = INSTALLUILEVEL(4i32);
3155 pub const INSTALLUILEVEL_FULL: INSTALLUILEVEL = INSTALLUILEVEL(5i32);
3156 pub const INSTALLUILEVEL_ENDDIALOG: INSTALLUILEVEL = INSTALLUILEVEL(128i32);
3157 pub const INSTALLUILEVEL_PROGRESSONLY: INSTALLUILEVEL = INSTALLUILEVEL(64i32);
3158 pub const INSTALLUILEVEL_HIDECANCEL: INSTALLUILEVEL = INSTALLUILEVEL(32i32);
3159 pub const INSTALLUILEVEL_SOURCERESONLY: INSTALLUILEVEL = INSTALLUILEVEL(256i32);
3160 pub const INSTALLUILEVEL_UACONLY: INSTALLUILEVEL = INSTALLUILEVEL(512i32);
3161 impl ::std::convert::From<i32> for INSTALLUILEVEL {
from(value: i32) -> Self3162     fn from(value: i32) -> Self {
3163         Self(value)
3164     }
3165 }
3166 unsafe impl ::windows::runtime::Abi for INSTALLUILEVEL {
3167     type Abi = Self;
3168     type DefaultType = Self;
3169 }
3170 #[cfg(feature = "Win32_Foundation")]
3171 pub type INSTALLUI_HANDLERA = unsafe extern "system" fn(pvcontext: *mut ::std::ffi::c_void, imessagetype: u32, szmessage: super::super::Foundation::PSTR) -> i32;
3172 #[cfg(feature = "Win32_Foundation")]
3173 pub type INSTALLUI_HANDLERW = unsafe extern "system" fn(pvcontext: *mut ::std::ffi::c_void, imessagetype: u32, szmessage: super::super::Foundation::PWSTR) -> i32;
3174 #[repr(transparent)]
3175 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3176 pub struct IPMApplicationInfo(::windows::runtime::IUnknown);
3177 impl IPMApplicationInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3178     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3179         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3180         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3181     }
InstanceID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3182     pub unsafe fn InstanceID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3183         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3184         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3185     }
OfferID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3186     pub unsafe fn OfferID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3187         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3188         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3189     }
3190     #[cfg(feature = "Win32_Foundation")]
DefaultTask(&self, pdefaulttask: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3191     pub unsafe fn DefaultTask(&self, pdefaulttask: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3192         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdefaulttask)).ok()
3193     }
3194     #[cfg(feature = "Win32_Foundation")]
AppTitle(&self, papptitle: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3195     pub unsafe fn AppTitle(&self, papptitle: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3196         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(papptitle)).ok()
3197     }
3198     #[cfg(feature = "Win32_Foundation")]
IconPath(&self, pappiconpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3199     pub unsafe fn IconPath(&self, pappiconpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3200         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pappiconpath)).ok()
3201     }
3202     #[cfg(feature = "Win32_Foundation")]
NotificationState(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3203     pub unsafe fn NotificationState(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3204         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3205         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3206     }
AppInstallType(&self) -> ::windows::runtime::Result<PM_APPLICATION_INSTALL_TYPE>3207     pub unsafe fn AppInstallType(&self) -> ::windows::runtime::Result<PM_APPLICATION_INSTALL_TYPE> {
3208         let mut result__: <PM_APPLICATION_INSTALL_TYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3209         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_APPLICATION_INSTALL_TYPE>(result__)
3210     }
State(&self) -> ::windows::runtime::Result<PM_APPLICATION_STATE>3211     pub unsafe fn State(&self) -> ::windows::runtime::Result<PM_APPLICATION_STATE> {
3212         let mut result__: <PM_APPLICATION_STATE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3213         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_APPLICATION_STATE>(result__)
3214     }
3215     #[cfg(feature = "Win32_Foundation")]
IsRevoked(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3216     pub unsafe fn IsRevoked(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3217         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3218         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3219     }
3220     #[cfg(feature = "Win32_Foundation")]
UpdateAvailable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3221     pub unsafe fn UpdateAvailable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3222         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3223         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3224     }
3225     #[cfg(feature = "Win32_Foundation")]
InstallDate(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME>3226     pub unsafe fn InstallDate(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME> {
3227         let mut result__: <super::super::Foundation::FILETIME as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3228         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::FILETIME>(result__)
3229     }
3230     #[cfg(feature = "Win32_Foundation")]
IsUninstallable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3231     pub unsafe fn IsUninstallable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3232         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3233         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3234     }
3235     #[cfg(feature = "Win32_Foundation")]
IsThemable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3236     pub unsafe fn IsThemable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3237         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3238         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3239     }
3240     #[cfg(feature = "Win32_Foundation")]
IsTrial(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3241     pub unsafe fn IsTrial(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3242         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3243         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3244     }
3245     #[cfg(feature = "Win32_Foundation")]
InstallPath(&self, pinstallpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3246     pub unsafe fn InstallPath(&self, pinstallpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3247         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), ::std::mem::transmute(pinstallpath)).ok()
3248     }
3249     #[cfg(feature = "Win32_Foundation")]
DataRoot(&self, pdataroot: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3250     pub unsafe fn DataRoot(&self, pdataroot: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3251         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdataroot)).ok()
3252     }
Genre(&self) -> ::windows::runtime::Result<PM_APP_GENRE>3253     pub unsafe fn Genre(&self) -> ::windows::runtime::Result<PM_APP_GENRE> {
3254         let mut result__: <PM_APP_GENRE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3255         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_APP_GENRE>(result__)
3256     }
3257     #[cfg(feature = "Win32_Foundation")]
Publisher(&self, ppublisher: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3258     pub unsafe fn Publisher(&self, ppublisher: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3259         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppublisher)).ok()
3260     }
3261     #[cfg(feature = "Win32_Foundation")]
Author(&self, pauthor: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3262     pub unsafe fn Author(&self, pauthor: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3263         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(pauthor)).ok()
3264     }
3265     #[cfg(feature = "Win32_Foundation")]
Description(&self, pdescription: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3266     pub unsafe fn Description(&self, pdescription: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3267         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdescription)).ok()
3268     }
3269     #[cfg(feature = "Win32_Foundation")]
Version(&self, pversion: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3270     pub unsafe fn Version(&self, pversion: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3271         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), ::std::mem::transmute(pversion)).ok()
3272     }
3273     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3274     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3275         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
3276     }
AppPlatMajorVersion(&self) -> ::windows::runtime::Result<u8>3277     pub unsafe fn AppPlatMajorVersion(&self) -> ::windows::runtime::Result<u8> {
3278         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3279         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u8>(result__)
3280     }
AppPlatMinorVersion(&self) -> ::windows::runtime::Result<u8>3281     pub unsafe fn AppPlatMinorVersion(&self) -> ::windows::runtime::Result<u8> {
3282         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3283         (::windows::runtime::Interface::vtable(self).27)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u8>(result__)
3284     }
PublisherID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3285     pub unsafe fn PublisherID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3286         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3287         (::windows::runtime::Interface::vtable(self).28)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3288     }
3289     #[cfg(feature = "Win32_Foundation")]
IsMultiCore(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3290     pub unsafe fn IsMultiCore(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3291         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3292         (::windows::runtime::Interface::vtable(self).29)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3293     }
3294     #[cfg(feature = "Win32_Foundation")]
SID(&self, psid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3295     pub unsafe fn SID(&self, psid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3296         (::windows::runtime::Interface::vtable(self).30)(::std::mem::transmute_copy(self), ::std::mem::transmute(psid)).ok()
3297     }
AppPlatMajorVersionLightUp(&self) -> ::windows::runtime::Result<u8>3298     pub unsafe fn AppPlatMajorVersionLightUp(&self) -> ::windows::runtime::Result<u8> {
3299         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3300         (::windows::runtime::Interface::vtable(self).31)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u8>(result__)
3301     }
AppPlatMinorVersionLightUp(&self) -> ::windows::runtime::Result<u8>3302     pub unsafe fn AppPlatMinorVersionLightUp(&self) -> ::windows::runtime::Result<u8> {
3303         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3304         (::windows::runtime::Interface::vtable(self).32)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u8>(result__)
3305     }
3306     #[cfg(feature = "Win32_Foundation")]
set_UpdateAvailable<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isupdateavailable: Param0) -> ::windows::runtime::Result<()>3307     pub unsafe fn set_UpdateAvailable<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isupdateavailable: Param0) -> ::windows::runtime::Result<()> {
3308         (::windows::runtime::Interface::vtable(self).33)(::std::mem::transmute_copy(self), isupdateavailable.into_param().abi()).ok()
3309     }
3310     #[cfg(feature = "Win32_Foundation")]
set_NotificationState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isnotified: Param0) -> ::windows::runtime::Result<()>3311     pub unsafe fn set_NotificationState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isnotified: Param0) -> ::windows::runtime::Result<()> {
3312         (::windows::runtime::Interface::vtable(self).34)(::std::mem::transmute_copy(self), isnotified.into_param().abi()).ok()
3313     }
3314     #[cfg(feature = "Win32_Foundation")]
set_IconPath<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, appiconpath: Param0) -> ::windows::runtime::Result<()>3315     pub unsafe fn set_IconPath<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, appiconpath: Param0) -> ::windows::runtime::Result<()> {
3316         (::windows::runtime::Interface::vtable(self).35)(::std::mem::transmute_copy(self), appiconpath.into_param().abi()).ok()
3317     }
3318     #[cfg(feature = "Win32_Foundation")]
set_UninstallableState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isuninstallable: Param0) -> ::windows::runtime::Result<()>3319     pub unsafe fn set_UninstallableState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isuninstallable: Param0) -> ::windows::runtime::Result<()> {
3320         (::windows::runtime::Interface::vtable(self).36)(::std::mem::transmute_copy(self), isuninstallable.into_param().abi()).ok()
3321     }
3322     #[cfg(feature = "Win32_Foundation")]
IsPinableOnKidZone(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3323     pub unsafe fn IsPinableOnKidZone(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3324         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3325         (::windows::runtime::Interface::vtable(self).37)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3326     }
3327     #[cfg(feature = "Win32_Foundation")]
IsOriginallyPreInstalled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3328     pub unsafe fn IsOriginallyPreInstalled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3329         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3330         (::windows::runtime::Interface::vtable(self).38)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3331     }
3332     #[cfg(feature = "Win32_Foundation")]
IsInstallOnSD(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3333     pub unsafe fn IsInstallOnSD(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3334         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3335         (::windows::runtime::Interface::vtable(self).39)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3336     }
3337     #[cfg(feature = "Win32_Foundation")]
IsOptoutOnSD(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3338     pub unsafe fn IsOptoutOnSD(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3339         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3340         (::windows::runtime::Interface::vtable(self).40)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3341     }
3342     #[cfg(feature = "Win32_Foundation")]
IsOptoutBackupRestore(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3343     pub unsafe fn IsOptoutBackupRestore(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3344         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3345         (::windows::runtime::Interface::vtable(self).41)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3346     }
3347     #[cfg(feature = "Win32_Foundation")]
set_EnterpriseDisabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isdisabled: Param0) -> ::windows::runtime::Result<()>3348     pub unsafe fn set_EnterpriseDisabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isdisabled: Param0) -> ::windows::runtime::Result<()> {
3349         (::windows::runtime::Interface::vtable(self).42)(::std::mem::transmute_copy(self), isdisabled.into_param().abi()).ok()
3350     }
3351     #[cfg(feature = "Win32_Foundation")]
set_EnterpriseUninstallable<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isuninstallable: Param0) -> ::windows::runtime::Result<()>3352     pub unsafe fn set_EnterpriseUninstallable<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isuninstallable: Param0) -> ::windows::runtime::Result<()> {
3353         (::windows::runtime::Interface::vtable(self).43)(::std::mem::transmute_copy(self), isuninstallable.into_param().abi()).ok()
3354     }
3355     #[cfg(feature = "Win32_Foundation")]
EnterpriseDisabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3356     pub unsafe fn EnterpriseDisabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3357         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3358         (::windows::runtime::Interface::vtable(self).44)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3359     }
3360     #[cfg(feature = "Win32_Foundation")]
EnterpriseUninstallable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3361     pub unsafe fn EnterpriseUninstallable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3362         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3363         (::windows::runtime::Interface::vtable(self).45)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3364     }
3365     #[cfg(feature = "Win32_Foundation")]
IsVisibleOnAppList(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3366     pub unsafe fn IsVisibleOnAppList(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3367         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3368         (::windows::runtime::Interface::vtable(self).46)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3369     }
3370     #[cfg(feature = "Win32_Foundation")]
IsInboxApp(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3371     pub unsafe fn IsInboxApp(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3372         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3373         (::windows::runtime::Interface::vtable(self).47)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3374     }
StorageID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3375     pub unsafe fn StorageID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3376         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3377         (::windows::runtime::Interface::vtable(self).48)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3378     }
3379     #[cfg(feature = "Win32_Foundation")]
StartAppBlob(&self, pblob: *mut PM_STARTAPPBLOB) -> ::windows::runtime::Result<()>3380     pub unsafe fn StartAppBlob(&self, pblob: *mut PM_STARTAPPBLOB) -> ::windows::runtime::Result<()> {
3381         (::windows::runtime::Interface::vtable(self).49)(::std::mem::transmute_copy(self), ::std::mem::transmute(pblob)).ok()
3382     }
3383     #[cfg(feature = "Win32_Foundation")]
IsMovable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3384     pub unsafe fn IsMovable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3385         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3386         (::windows::runtime::Interface::vtable(self).50)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3387     }
DeploymentAppEnumerationHubFilter(&self) -> ::windows::runtime::Result<PM_TILE_HUBTYPE>3388     pub unsafe fn DeploymentAppEnumerationHubFilter(&self) -> ::windows::runtime::Result<PM_TILE_HUBTYPE> {
3389         let mut result__: <PM_TILE_HUBTYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3390         (::windows::runtime::Interface::vtable(self).51)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_TILE_HUBTYPE>(result__)
3391     }
3392     #[cfg(feature = "Win32_Foundation")]
ModifiedDate(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME>3393     pub unsafe fn ModifiedDate(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME> {
3394         let mut result__: <super::super::Foundation::FILETIME as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3395         (::windows::runtime::Interface::vtable(self).52)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::FILETIME>(result__)
3396     }
3397     #[cfg(feature = "Win32_Foundation")]
IsOriginallyRestored(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3398     pub unsafe fn IsOriginallyRestored(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3399         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3400         (::windows::runtime::Interface::vtable(self).53)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3401     }
3402     #[cfg(feature = "Win32_Foundation")]
ShouldDeferMdilBind(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3403     pub unsafe fn ShouldDeferMdilBind(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3404         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3405         (::windows::runtime::Interface::vtable(self).54)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3406     }
3407     #[cfg(feature = "Win32_Foundation")]
IsFullyPreInstall(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3408     pub unsafe fn IsFullyPreInstall(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3409         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3410         (::windows::runtime::Interface::vtable(self).55)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3411     }
3412     #[cfg(feature = "Win32_Foundation")]
set_IsMdilMaintenanceNeeded<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fismdilmaintenanceneeded: Param0) -> ::windows::runtime::Result<()>3413     pub unsafe fn set_IsMdilMaintenanceNeeded<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fismdilmaintenanceneeded: Param0) -> ::windows::runtime::Result<()> {
3414         (::windows::runtime::Interface::vtable(self).56)(::std::mem::transmute_copy(self), fismdilmaintenanceneeded.into_param().abi()).ok()
3415     }
3416     #[cfg(feature = "Win32_Foundation")]
set_Title<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, apptitle: Param0) -> ::windows::runtime::Result<()>3417     pub unsafe fn set_Title<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, apptitle: Param0) -> ::windows::runtime::Result<()> {
3418         (::windows::runtime::Interface::vtable(self).57)(::std::mem::transmute_copy(self), apptitle.into_param().abi()).ok()
3419     }
3420 }
3421 unsafe impl ::windows::runtime::Interface for IPMApplicationInfo {
3422     type Vtable = IPMApplicationInfo_abi;
3423     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1353692554, 17292, 16520, [151, 137, 248, 196, 137, 152, 41, 199]);
3424 }
3425 impl ::std::convert::From<IPMApplicationInfo> for ::windows::runtime::IUnknown {
from(value: IPMApplicationInfo) -> Self3426     fn from(value: IPMApplicationInfo) -> Self {
3427         unsafe { ::std::mem::transmute(value) }
3428     }
3429 }
3430 impl ::std::convert::From<&IPMApplicationInfo> for ::windows::runtime::IUnknown {
from(value: &IPMApplicationInfo) -> Self3431     fn from(value: &IPMApplicationInfo) -> Self {
3432         ::std::convert::From::from(::std::clone::Clone::clone(value))
3433     }
3434 }
3435 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMApplicationInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3436     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3437         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3438     }
3439 }
3440 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMApplicationInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3441     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3442         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3443     }
3444 }
3445 #[repr(C)]
3446 #[doc(hidden)]
3447 pub struct IPMApplicationInfo_abi(
3448     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3449     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3450     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3451     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3452     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstanceid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3453     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pofferid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3454     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdefaulttask: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3455     #[cfg(not(feature = "Win32_Foundation"))] usize,
3456     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, papptitle: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3457     #[cfg(not(feature = "Win32_Foundation"))] usize,
3458     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pappiconpath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3459     #[cfg(not(feature = "Win32_Foundation"))] usize,
3460     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisnotified: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3461     #[cfg(not(feature = "Win32_Foundation"))] usize,
3462     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pappinstalltype: *mut PM_APPLICATION_INSTALL_TYPE) -> ::windows::runtime::HRESULT,
3463     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstate: *mut PM_APPLICATION_STATE) -> ::windows::runtime::HRESULT,
3464     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisrevoked: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3465     #[cfg(not(feature = "Win32_Foundation"))] usize,
3466     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisupdateavailable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3467     #[cfg(not(feature = "Win32_Foundation"))] usize,
3468     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstalldate: *mut super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
3469     #[cfg(not(feature = "Win32_Foundation"))] usize,
3470     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisuninstallable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3471     #[cfg(not(feature = "Win32_Foundation"))] usize,
3472     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisthemable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3473     #[cfg(not(feature = "Win32_Foundation"))] usize,
3474     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pistrial: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3475     #[cfg(not(feature = "Win32_Foundation"))] usize,
3476     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstallpath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3477     #[cfg(not(feature = "Win32_Foundation"))] usize,
3478     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdataroot: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3479     #[cfg(not(feature = "Win32_Foundation"))] usize,
3480     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pgenre: *mut PM_APP_GENRE) -> ::windows::runtime::HRESULT,
3481     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppublisher: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3482     #[cfg(not(feature = "Win32_Foundation"))] usize,
3483     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pauthor: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3484     #[cfg(not(feature = "Win32_Foundation"))] usize,
3485     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdescription: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3486     #[cfg(not(feature = "Win32_Foundation"))] usize,
3487     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pversion: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3488     #[cfg(not(feature = "Win32_Foundation"))] usize,
3489     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3490     #[cfg(not(feature = "Win32_Foundation"))] usize,
3491     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pmajorver: *mut u8) -> ::windows::runtime::HRESULT,
3492     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pminorver: *mut u8) -> ::windows::runtime::HRESULT,
3493     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppublisherid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3494     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pismulticore: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3495     #[cfg(not(feature = "Win32_Foundation"))] usize,
3496     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3497     #[cfg(not(feature = "Win32_Foundation"))] usize,
3498     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pmajorver: *mut u8) -> ::windows::runtime::HRESULT,
3499     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pminorver: *mut u8) -> ::windows::runtime::HRESULT,
3500     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isupdateavailable: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3501     #[cfg(not(feature = "Win32_Foundation"))] usize,
3502     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isnotified: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3503     #[cfg(not(feature = "Win32_Foundation"))] usize,
3504     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, appiconpath: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3505     #[cfg(not(feature = "Win32_Foundation"))] usize,
3506     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isuninstallable: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3507     #[cfg(not(feature = "Win32_Foundation"))] usize,
3508     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pispinable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3509     #[cfg(not(feature = "Win32_Foundation"))] usize,
3510     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pispreinstalled: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3511     #[cfg(not(feature = "Win32_Foundation"))] usize,
3512     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisinstallonsd: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3513     #[cfg(not(feature = "Win32_Foundation"))] usize,
3514     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisoptoutonsd: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3515     #[cfg(not(feature = "Win32_Foundation"))] usize,
3516     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisoptoutbackuprestore: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3517     #[cfg(not(feature = "Win32_Foundation"))] usize,
3518     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isdisabled: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3519     #[cfg(not(feature = "Win32_Foundation"))] usize,
3520     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isuninstallable: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3521     #[cfg(not(feature = "Win32_Foundation"))] usize,
3522     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isdisabled: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3523     #[cfg(not(feature = "Win32_Foundation"))] usize,
3524     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isuninstallable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3525     #[cfg(not(feature = "Win32_Foundation"))] usize,
3526     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisvisible: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3527     #[cfg(not(feature = "Win32_Foundation"))] usize,
3528     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisinboxapp: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3529     #[cfg(not(feature = "Win32_Foundation"))] usize,
3530     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstorageid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3531     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pblob: *mut ::std::mem::ManuallyDrop<PM_STARTAPPBLOB>) -> ::windows::runtime::HRESULT,
3532     #[cfg(not(feature = "Win32_Foundation"))] usize,
3533     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pismovable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3534     #[cfg(not(feature = "Win32_Foundation"))] usize,
3535     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: *mut PM_TILE_HUBTYPE) -> ::windows::runtime::HRESULT,
3536     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pmodifieddate: *mut super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
3537     #[cfg(not(feature = "Win32_Foundation"))] usize,
3538     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisrestored: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3539     #[cfg(not(feature = "Win32_Foundation"))] usize,
3540     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pfdefermdilbind: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3541     #[cfg(not(feature = "Win32_Foundation"))] usize,
3542     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pfisfullypreinstall: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3543     #[cfg(not(feature = "Win32_Foundation"))] usize,
3544     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, fismdilmaintenanceneeded: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3545     #[cfg(not(feature = "Win32_Foundation"))] usize,
3546     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, apptitle: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3547     #[cfg(not(feature = "Win32_Foundation"))] usize,
3548 );
3549 #[repr(transparent)]
3550 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3551 pub struct IPMApplicationInfoEnumerator(::windows::runtime::IUnknown);
3552 impl IPMApplicationInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMApplicationInfo>3553     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMApplicationInfo> {
3554         let mut result__: <IPMApplicationInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3555         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMApplicationInfo>(result__)
3556     }
3557 }
3558 unsafe impl ::windows::runtime::Interface for IPMApplicationInfoEnumerator {
3559     type Vtable = IPMApplicationInfoEnumerator_abi;
3560     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(247736982, 19782, 19910, [163, 217, 167, 172, 170, 192, 245, 250]);
3561 }
3562 impl ::std::convert::From<IPMApplicationInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMApplicationInfoEnumerator) -> Self3563     fn from(value: IPMApplicationInfoEnumerator) -> Self {
3564         unsafe { ::std::mem::transmute(value) }
3565     }
3566 }
3567 impl ::std::convert::From<&IPMApplicationInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMApplicationInfoEnumerator) -> Self3568     fn from(value: &IPMApplicationInfoEnumerator) -> Self {
3569         ::std::convert::From::from(::std::clone::Clone::clone(value))
3570     }
3571 }
3572 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMApplicationInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3573     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3574         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3575     }
3576 }
3577 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMApplicationInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3578     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3579         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3580     }
3581 }
3582 #[repr(C)]
3583 #[doc(hidden)]
3584 pub struct IPMApplicationInfoEnumerator_abi(
3585     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3586     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3587     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3588     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppappinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3589 );
3590 #[repr(transparent)]
3591 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3592 pub struct IPMBackgroundServiceAgentInfo(::windows::runtime::IUnknown);
3593 impl IPMBackgroundServiceAgentInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3594     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3595         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3596         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3597     }
3598     #[cfg(feature = "Win32_Foundation")]
TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3599     pub unsafe fn TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3600         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptaskid)).ok()
3601     }
BSAID(&self) -> ::windows::runtime::Result<u32>3602     pub unsafe fn BSAID(&self) -> ::windows::runtime::Result<u32> {
3603         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3604         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3605     }
3606     #[cfg(feature = "Win32_Foundation")]
BGSpecifier(&self, pbgspecifier: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3607     pub unsafe fn BGSpecifier(&self, pbgspecifier: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3608         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbgspecifier)).ok()
3609     }
3610     #[cfg(feature = "Win32_Foundation")]
BGName(&self, pbgname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3611     pub unsafe fn BGName(&self, pbgname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3612         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbgname)).ok()
3613     }
3614     #[cfg(feature = "Win32_Foundation")]
BGSource(&self, pbgsource: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3615     pub unsafe fn BGSource(&self, pbgsource: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3616         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbgsource)).ok()
3617     }
3618     #[cfg(feature = "Win32_Foundation")]
BGType(&self, pbgtype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3619     pub unsafe fn BGType(&self, pbgtype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3620         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbgtype)).ok()
3621     }
3622     #[cfg(feature = "Win32_Foundation")]
IsPeriodic(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3623     pub unsafe fn IsPeriodic(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3624         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3625         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3626     }
3627     #[cfg(feature = "Win32_Foundation")]
IsScheduled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3628     pub unsafe fn IsScheduled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3629         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3630         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3631     }
3632     #[cfg(feature = "Win32_Foundation")]
IsScheduleAllowed(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3633     pub unsafe fn IsScheduleAllowed(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3634         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3635         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3636     }
3637     #[cfg(feature = "Win32_Foundation")]
Description(&self, pdescription: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3638     pub unsafe fn Description(&self, pdescription: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3639         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdescription)).ok()
3640     }
3641     #[cfg(feature = "Win32_Foundation")]
IsLaunchOnBoot(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3642     pub unsafe fn IsLaunchOnBoot(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3643         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3644         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3645     }
3646     #[cfg(feature = "Win32_Foundation")]
set_IsScheduled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isscheduled: Param0) -> ::windows::runtime::Result<()>3647     pub unsafe fn set_IsScheduled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isscheduled: Param0) -> ::windows::runtime::Result<()> {
3648         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), isscheduled.into_param().abi()).ok()
3649     }
3650     #[cfg(feature = "Win32_Foundation")]
set_IsScheduleAllowed<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isscheduleallowed: Param0) -> ::windows::runtime::Result<()>3651     pub unsafe fn set_IsScheduleAllowed<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, isscheduleallowed: Param0) -> ::windows::runtime::Result<()> {
3652         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), isscheduleallowed.into_param().abi()).ok()
3653     }
3654 }
3655 unsafe impl ::windows::runtime::Interface for IPMBackgroundServiceAgentInfo {
3656     type Vtable = IPMBackgroundServiceAgentInfo_abi;
3657     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(982206170, 37516, 18553, [153, 140, 9, 220, 150, 243, 212, 144]);
3658 }
3659 impl ::std::convert::From<IPMBackgroundServiceAgentInfo> for ::windows::runtime::IUnknown {
from(value: IPMBackgroundServiceAgentInfo) -> Self3660     fn from(value: IPMBackgroundServiceAgentInfo) -> Self {
3661         unsafe { ::std::mem::transmute(value) }
3662     }
3663 }
3664 impl ::std::convert::From<&IPMBackgroundServiceAgentInfo> for ::windows::runtime::IUnknown {
from(value: &IPMBackgroundServiceAgentInfo) -> Self3665     fn from(value: &IPMBackgroundServiceAgentInfo) -> Self {
3666         ::std::convert::From::from(::std::clone::Clone::clone(value))
3667     }
3668 }
3669 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMBackgroundServiceAgentInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3670     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3671         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3672     }
3673 }
3674 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMBackgroundServiceAgentInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3675     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3676         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3677     }
3678 }
3679 #[repr(C)]
3680 #[doc(hidden)]
3681 pub struct IPMBackgroundServiceAgentInfo_abi(
3682     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3683     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3684     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3685     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3686     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptaskid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3687     #[cfg(not(feature = "Win32_Foundation"))] usize,
3688     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbsaid: *mut u32) -> ::windows::runtime::HRESULT,
3689     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbgspecifier: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3690     #[cfg(not(feature = "Win32_Foundation"))] usize,
3691     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbgname: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3692     #[cfg(not(feature = "Win32_Foundation"))] usize,
3693     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbgsource: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3694     #[cfg(not(feature = "Win32_Foundation"))] usize,
3695     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbgtype: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3696     #[cfg(not(feature = "Win32_Foundation"))] usize,
3697     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisperiodic: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3698     #[cfg(not(feature = "Win32_Foundation"))] usize,
3699     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisscheduled: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3700     #[cfg(not(feature = "Win32_Foundation"))] usize,
3701     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisscheduleallowed: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3702     #[cfg(not(feature = "Win32_Foundation"))] usize,
3703     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdescription: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3704     #[cfg(not(feature = "Win32_Foundation"))] usize,
3705     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plaunchonboot: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3706     #[cfg(not(feature = "Win32_Foundation"))] usize,
3707     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isscheduled: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3708     #[cfg(not(feature = "Win32_Foundation"))] usize,
3709     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isscheduleallowed: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3710     #[cfg(not(feature = "Win32_Foundation"))] usize,
3711 );
3712 #[repr(transparent)]
3713 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3714 pub struct IPMBackgroundServiceAgentInfoEnumerator(::windows::runtime::IUnknown);
3715 impl IPMBackgroundServiceAgentInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMBackgroundServiceAgentInfo>3716     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMBackgroundServiceAgentInfo> {
3717         let mut result__: <IPMBackgroundServiceAgentInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3718         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMBackgroundServiceAgentInfo>(result__)
3719     }
3720 }
3721 unsafe impl ::windows::runtime::Interface for IPMBackgroundServiceAgentInfoEnumerator {
3722     type Vtable = IPMBackgroundServiceAgentInfoEnumerator_abi;
3723     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(418062450, 43862, 17331, [135, 44, 190, 175, 183, 166, 179, 145]);
3724 }
3725 impl ::std::convert::From<IPMBackgroundServiceAgentInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMBackgroundServiceAgentInfoEnumerator) -> Self3726     fn from(value: IPMBackgroundServiceAgentInfoEnumerator) -> Self {
3727         unsafe { ::std::mem::transmute(value) }
3728     }
3729 }
3730 impl ::std::convert::From<&IPMBackgroundServiceAgentInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMBackgroundServiceAgentInfoEnumerator) -> Self3731     fn from(value: &IPMBackgroundServiceAgentInfoEnumerator) -> Self {
3732         ::std::convert::From::from(::std::clone::Clone::clone(value))
3733     }
3734 }
3735 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMBackgroundServiceAgentInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3736     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3737         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3738     }
3739 }
3740 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMBackgroundServiceAgentInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3741     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3742         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3743     }
3744 }
3745 #[repr(C)]
3746 #[doc(hidden)]
3747 pub struct IPMBackgroundServiceAgentInfoEnumerator_abi(
3748     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3749     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3750     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3751     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppbsainfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3752 );
3753 #[repr(transparent)]
3754 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3755 pub struct IPMBackgroundWorkerInfo(::windows::runtime::IUnknown);
3756 impl IPMBackgroundWorkerInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>3757     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
3758         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3759         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
3760     }
3761     #[cfg(feature = "Win32_Foundation")]
TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3762     pub unsafe fn TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3763         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptaskid)).ok()
3764     }
3765     #[cfg(feature = "Win32_Foundation")]
BGName(&self, pbgname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3766     pub unsafe fn BGName(&self, pbgname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3767         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbgname)).ok()
3768     }
MaxStartupLatency(&self) -> ::windows::runtime::Result<u32>3769     pub unsafe fn MaxStartupLatency(&self) -> ::windows::runtime::Result<u32> {
3770         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3771         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3772     }
ExpectedRuntime(&self) -> ::windows::runtime::Result<u32>3773     pub unsafe fn ExpectedRuntime(&self) -> ::windows::runtime::Result<u32> {
3774         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3775         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3776     }
3777     #[cfg(feature = "Win32_Foundation")]
IsBootWorker(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3778     pub unsafe fn IsBootWorker(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3779         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3780         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3781     }
3782 }
3783 unsafe impl ::windows::runtime::Interface for IPMBackgroundWorkerInfo {
3784     type Vtable = IPMBackgroundWorkerInfo_abi;
3785     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2111066907, 54207, 19307, [148, 243, 105, 192, 152, 177, 73, 125]);
3786 }
3787 impl ::std::convert::From<IPMBackgroundWorkerInfo> for ::windows::runtime::IUnknown {
from(value: IPMBackgroundWorkerInfo) -> Self3788     fn from(value: IPMBackgroundWorkerInfo) -> Self {
3789         unsafe { ::std::mem::transmute(value) }
3790     }
3791 }
3792 impl ::std::convert::From<&IPMBackgroundWorkerInfo> for ::windows::runtime::IUnknown {
from(value: &IPMBackgroundWorkerInfo) -> Self3793     fn from(value: &IPMBackgroundWorkerInfo) -> Self {
3794         ::std::convert::From::from(::std::clone::Clone::clone(value))
3795     }
3796 }
3797 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMBackgroundWorkerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3798     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3799         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3800     }
3801 }
3802 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMBackgroundWorkerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3803     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3804         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3805     }
3806 }
3807 #[repr(C)]
3808 #[doc(hidden)]
3809 pub struct IPMBackgroundWorkerInfo_abi(
3810     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3811     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3812     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3813     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
3814     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptaskid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3815     #[cfg(not(feature = "Win32_Foundation"))] usize,
3816     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbgname: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3817     #[cfg(not(feature = "Win32_Foundation"))] usize,
3818     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pmaxstartuplatency: *mut u32) -> ::windows::runtime::HRESULT,
3819     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pexpectedruntime: *mut u32) -> ::windows::runtime::HRESULT,
3820     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisbootworker: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3821     #[cfg(not(feature = "Win32_Foundation"))] usize,
3822 );
3823 #[repr(transparent)]
3824 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3825 pub struct IPMBackgroundWorkerInfoEnumerator(::windows::runtime::IUnknown);
3826 impl IPMBackgroundWorkerInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMBackgroundWorkerInfo>3827     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMBackgroundWorkerInfo> {
3828         let mut result__: <IPMBackgroundWorkerInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3829         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMBackgroundWorkerInfo>(result__)
3830     }
3831 }
3832 unsafe impl ::windows::runtime::Interface for IPMBackgroundWorkerInfoEnumerator {
3833     type Vtable = IPMBackgroundWorkerInfoEnumerator_abi;
3834     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2280946168, 37080, 20167, [146, 185, 114, 120, 126, 47, 99, 107]);
3835 }
3836 impl ::std::convert::From<IPMBackgroundWorkerInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMBackgroundWorkerInfoEnumerator) -> Self3837     fn from(value: IPMBackgroundWorkerInfoEnumerator) -> Self {
3838         unsafe { ::std::mem::transmute(value) }
3839     }
3840 }
3841 impl ::std::convert::From<&IPMBackgroundWorkerInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMBackgroundWorkerInfoEnumerator) -> Self3842     fn from(value: &IPMBackgroundWorkerInfoEnumerator) -> Self {
3843         ::std::convert::From::from(::std::clone::Clone::clone(value))
3844     }
3845 }
3846 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMBackgroundWorkerInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3847     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3848         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3849     }
3850 }
3851 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMBackgroundWorkerInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3852     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3853         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3854     }
3855 }
3856 #[repr(C)]
3857 #[doc(hidden)]
3858 pub struct IPMBackgroundWorkerInfoEnumerator_abi(
3859     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3860     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3861     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3862     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppbwinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3863 );
3864 #[repr(transparent)]
3865 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3866 pub struct IPMDeploymentManager(::windows::runtime::IUnknown);
3867 impl IPMDeploymentManager {
ReportDownloadBegin<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3868     pub unsafe fn ReportDownloadBegin<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3869         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3870     }
ReportDownloadProgress<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, usprogress: u16) -> ::windows::runtime::Result<()>3871     pub unsafe fn ReportDownloadProgress<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, usprogress: u16) -> ::windows::runtime::Result<()> {
3872         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(usprogress)).ok()
3873     }
ReportDownloadComplete<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, hrresult: ::windows::runtime::HRESULT) -> ::windows::runtime::Result<()>3874     pub unsafe fn ReportDownloadComplete<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, hrresult: ::windows::runtime::HRESULT) -> ::windows::runtime::Result<()> {
3875         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(hrresult)).ok()
3876     }
3877     #[cfg(feature = "Win32_Foundation")]
BeginInstall(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()>3878     pub unsafe fn BeginInstall(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()> {
3879         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(pinstallinfo)).ok()
3880     }
3881     #[cfg(feature = "Win32_Foundation")]
BeginUpdate(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()>3882     pub unsafe fn BeginUpdate(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()> {
3883         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(pupdateinfo)).ok()
3884     }
3885     #[cfg(feature = "Win32_Foundation")]
BeginDeployPackage(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()>3886     pub unsafe fn BeginDeployPackage(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()> {
3887         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pinstallinfo)).ok()
3888     }
3889     #[cfg(feature = "Win32_Foundation")]
BeginUpdateDeployedPackageLegacy(&self, pupdateinfo: *const PM_UPDATEINFO_LEGACY) -> ::windows::runtime::Result<()>3890     pub unsafe fn BeginUpdateDeployedPackageLegacy(&self, pupdateinfo: *const PM_UPDATEINFO_LEGACY) -> ::windows::runtime::Result<()> {
3891         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pupdateinfo)).ok()
3892     }
BeginUninstall<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3893     pub unsafe fn BeginUninstall<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3894         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3895     }
3896     #[cfg(feature = "Win32_Foundation")]
BeginEnterpriseAppInstall(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()>3897     pub unsafe fn BeginEnterpriseAppInstall(&self, pinstallinfo: *const PM_INSTALLINFO) -> ::windows::runtime::Result<()> {
3898         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(pinstallinfo)).ok()
3899     }
3900     #[cfg(feature = "Win32_Foundation")]
BeginEnterpriseAppUpdate(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()>3901     pub unsafe fn BeginEnterpriseAppUpdate(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()> {
3902         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(pupdateinfo)).ok()
3903     }
BeginUpdateLicense<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, offerid: Param1, pblicense: *const u8, cblicense: u32) -> ::windows::runtime::Result<()>3904     pub unsafe fn BeginUpdateLicense<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, offerid: Param1, pblicense: *const u8, cblicense: u32) -> ::windows::runtime::Result<()> {
3905         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), productid.into_param().abi(), offerid.into_param().abi(), ::std::mem::transmute(pblicense), ::std::mem::transmute(cblicense)).ok()
3906     }
3907     #[cfg(feature = "Win32_Foundation")]
GetLicenseChallenge<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, packagepath: Param0, ppbchallenge: *mut *mut u8, pcbchallenge: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::Result<()>3908     pub unsafe fn GetLicenseChallenge<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, packagepath: Param0, ppbchallenge: *mut *mut u8, pcbchallenge: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::Result<()> {
3909         (::windows::runtime::Interface::vtable(self).14)(
3910             ::std::mem::transmute_copy(self),
3911             packagepath.into_param().abi(),
3912             ::std::mem::transmute(ppbchallenge),
3913             ::std::mem::transmute(pcbchallenge),
3914             ::std::mem::transmute(ppbkid),
3915             ::std::mem::transmute(pcbkid),
3916             ::std::mem::transmute(ppbdeviceid),
3917             ::std::mem::transmute(pcbdeviceid),
3918             ::std::mem::transmute(ppbsaltvalue),
3919             ::std::mem::transmute(pcbsaltvalue),
3920             ::std::mem::transmute(ppbkgvvalue),
3921             ::std::mem::transmute(pcbkgvvalue),
3922         )
3923         .ok()
3924     }
GetLicenseChallengeByProductID<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, ppbchallenge: *mut *mut u8, pcblicense: *mut u32) -> ::windows::runtime::Result<()>3925     pub unsafe fn GetLicenseChallengeByProductID<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, ppbchallenge: *mut *mut u8, pcblicense: *mut u32) -> ::windows::runtime::Result<()> {
3926         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(ppbchallenge), ::std::mem::transmute(pcblicense)).ok()
3927     }
GetLicenseChallengeByProductID2<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, ppbchallenge: *mut *mut u8, pcblicense: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::Result<()>3928     pub unsafe fn GetLicenseChallengeByProductID2<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, ppbchallenge: *mut *mut u8, pcblicense: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::Result<()> {
3929         (::windows::runtime::Interface::vtable(self).16)(
3930             ::std::mem::transmute_copy(self),
3931             productid.into_param().abi(),
3932             ::std::mem::transmute(ppbchallenge),
3933             ::std::mem::transmute(pcblicense),
3934             ::std::mem::transmute(ppbkid),
3935             ::std::mem::transmute(pcbkid),
3936             ::std::mem::transmute(ppbdeviceid),
3937             ::std::mem::transmute(pcbdeviceid),
3938             ::std::mem::transmute(ppbsaltvalue),
3939             ::std::mem::transmute(pcbsaltvalue),
3940             ::std::mem::transmute(ppbkgvvalue),
3941             ::std::mem::transmute(pcbkgvvalue),
3942         )
3943         .ok()
3944     }
RevokeLicense<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3945     pub unsafe fn RevokeLicense<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3946         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3947     }
3948     #[cfg(feature = "Win32_System_Com")]
RebindMdilBinaries<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, filenames: *const super::Com::SAFEARRAY) -> ::windows::runtime::Result<()>3949     pub unsafe fn RebindMdilBinaries<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, filenames: *const super::Com::SAFEARRAY) -> ::windows::runtime::Result<()> {
3950         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(filenames)).ok()
3951     }
RebindAllMdilBinaries<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, instanceid: Param1) -> ::windows::runtime::Result<()>3952     pub unsafe fn RebindAllMdilBinaries<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, instanceid: Param1) -> ::windows::runtime::Result<()> {
3953         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), productid.into_param().abi(), instanceid.into_param().abi()).ok()
3954     }
3955     #[cfg(feature = "Win32_System_Com")]
RegenerateXbf<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, assemblypaths: *const super::Com::SAFEARRAY) -> ::windows::runtime::Result<()>3956     pub unsafe fn RegenerateXbf<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, assemblypaths: *const super::Com::SAFEARRAY) -> ::windows::runtime::Result<()> {
3957         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(assemblypaths)).ok()
3958     }
GenerateXbfForCurrentLocale<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3959     pub unsafe fn GenerateXbfForCurrentLocale<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3960         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3961     }
3962     #[cfg(feature = "Win32_Foundation")]
BeginProvision<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, xmlpath: Param1) -> ::windows::runtime::Result<()>3963     pub unsafe fn BeginProvision<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, xmlpath: Param1) -> ::windows::runtime::Result<()> {
3964         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), productid.into_param().abi(), xmlpath.into_param().abi()).ok()
3965     }
BeginDeprovision<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3966     pub unsafe fn BeginDeprovision<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3967         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3968     }
ReindexSQLCEDatabases<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3969     pub unsafe fn ReindexSQLCEDatabases<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3970         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3971     }
SetApplicationsNeedMaintenance(&self, requiredmaintenanceoperations: u32) -> ::windows::runtime::Result<u32>3972     pub unsafe fn SetApplicationsNeedMaintenance(&self, requiredmaintenanceoperations: u32) -> ::windows::runtime::Result<u32> {
3973         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3974         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), ::std::mem::transmute(requiredmaintenanceoperations), &mut result__).from_abi::<u32>(result__)
3975     }
UpdateChamberProfile<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3976     pub unsafe fn UpdateChamberProfile<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3977         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3978     }
3979     #[cfg(feature = "Win32_Foundation")]
EnterprisePolicyIsApplicationAllowed<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, productid: Param0, publishername: Param1) -> ::windows::runtime::Result<super::super::Foundation::BOOL>3980     pub unsafe fn EnterprisePolicyIsApplicationAllowed<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, productid: Param0, publishername: Param1) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
3981         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3982         (::windows::runtime::Interface::vtable(self).27)(::std::mem::transmute_copy(self), productid.into_param().abi(), publishername.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
3983     }
3984     #[cfg(feature = "Win32_Foundation")]
BeginUpdateDeployedPackage(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()>3985     pub unsafe fn BeginUpdateDeployedPackage(&self, pupdateinfo: *const PM_UPDATEINFO) -> ::windows::runtime::Result<()> {
3986         (::windows::runtime::Interface::vtable(self).28)(::std::mem::transmute_copy(self), ::std::mem::transmute(pupdateinfo)).ok()
3987     }
ReportRestoreCancelled<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3988     pub unsafe fn ReportRestoreCancelled<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3989         (::windows::runtime::Interface::vtable(self).29)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
3990     }
3991     #[cfg(feature = "Win32_Foundation")]
ResolveResourceString<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, resourcestring: Param0, presolvedresourcestring: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>3992     pub unsafe fn ResolveResourceString<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, resourcestring: Param0, presolvedresourcestring: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
3993         (::windows::runtime::Interface::vtable(self).30)(::std::mem::transmute_copy(self), resourcestring.into_param().abi(), ::std::mem::transmute(presolvedresourcestring)).ok()
3994     }
UpdateCapabilitiesForModernApps(&self) -> ::windows::runtime::Result<()>3995     pub unsafe fn UpdateCapabilitiesForModernApps(&self) -> ::windows::runtime::Result<()> {
3996         (::windows::runtime::Interface::vtable(self).31)(::std::mem::transmute_copy(self)).ok()
3997     }
ReportDownloadStatusUpdate<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()>3998     pub unsafe fn ReportDownloadStatusUpdate<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<()> {
3999         (::windows::runtime::Interface::vtable(self).32)(::std::mem::transmute_copy(self), productid.into_param().abi()).ok()
4000     }
BeginUninstallWithOptions<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, removaloptions: u32) -> ::windows::runtime::Result<()>4001     pub unsafe fn BeginUninstallWithOptions<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, removaloptions: u32) -> ::windows::runtime::Result<()> {
4002         (::windows::runtime::Interface::vtable(self).33)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(removaloptions)).ok()
4003     }
BindDeferredMdilBinaries(&self) -> ::windows::runtime::Result<()>4004     pub unsafe fn BindDeferredMdilBinaries(&self) -> ::windows::runtime::Result<()> {
4005         (::windows::runtime::Interface::vtable(self).34)(::std::mem::transmute_copy(self)).ok()
4006     }
4007     #[cfg(feature = "Win32_Foundation")]
GenerateXamlLightupXbfForCurrentLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, packagefamilyname: Param0) -> ::windows::runtime::Result<()>4008     pub unsafe fn GenerateXamlLightupXbfForCurrentLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, packagefamilyname: Param0) -> ::windows::runtime::Result<()> {
4009         (::windows::runtime::Interface::vtable(self).35)(::std::mem::transmute_copy(self), packagefamilyname.into_param().abi()).ok()
4010     }
AddLicenseForAppx<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, pblicense: *const u8, cblicense: u32, pbplayreadyheader: *const u8, cbplayreadyheader: u32) -> ::windows::runtime::Result<()>4011     pub unsafe fn AddLicenseForAppx<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0, pblicense: *const u8, cblicense: u32, pbplayreadyheader: *const u8, cbplayreadyheader: u32) -> ::windows::runtime::Result<()> {
4012         (::windows::runtime::Interface::vtable(self).36)(::std::mem::transmute_copy(self), productid.into_param().abi(), ::std::mem::transmute(pblicense), ::std::mem::transmute(cblicense), ::std::mem::transmute(pbplayreadyheader), ::std::mem::transmute(cbplayreadyheader)).ok()
4013     }
FixJunctionsForAppsOnSDCard(&self) -> ::windows::runtime::Result<()>4014     pub unsafe fn FixJunctionsForAppsOnSDCard(&self) -> ::windows::runtime::Result<()> {
4015         (::windows::runtime::Interface::vtable(self).37)(::std::mem::transmute_copy(self)).ok()
4016     }
4017 }
4018 unsafe impl ::windows::runtime::Interface for IPMDeploymentManager {
4019     type Vtable = IPMDeploymentManager_abi;
4020     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(905414138, 6521, 19083, [188, 143, 253, 112, 235, 13, 21, 68]);
4021 }
4022 impl ::std::convert::From<IPMDeploymentManager> for ::windows::runtime::IUnknown {
from(value: IPMDeploymentManager) -> Self4023     fn from(value: IPMDeploymentManager) -> Self {
4024         unsafe { ::std::mem::transmute(value) }
4025     }
4026 }
4027 impl ::std::convert::From<&IPMDeploymentManager> for ::windows::runtime::IUnknown {
from(value: &IPMDeploymentManager) -> Self4028     fn from(value: &IPMDeploymentManager) -> Self {
4029         ::std::convert::From::from(::std::clone::Clone::clone(value))
4030     }
4031 }
4032 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMDeploymentManager {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4033     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4034         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4035     }
4036 }
4037 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMDeploymentManager {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4038     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4039         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4040     }
4041 }
4042 #[repr(C)]
4043 #[doc(hidden)]
4044 pub struct IPMDeploymentManager_abi(
4045     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4046     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4047     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4048     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4049     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, usprogress: u16) -> ::windows::runtime::HRESULT,
4050     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, hrresult: ::windows::runtime::HRESULT) -> ::windows::runtime::HRESULT,
4051     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstallinfo: *const ::std::mem::ManuallyDrop<PM_INSTALLINFO>) -> ::windows::runtime::HRESULT,
4052     #[cfg(not(feature = "Win32_Foundation"))] usize,
4053     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pupdateinfo: *const ::std::mem::ManuallyDrop<PM_UPDATEINFO>) -> ::windows::runtime::HRESULT,
4054     #[cfg(not(feature = "Win32_Foundation"))] usize,
4055     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstallinfo: *const ::std::mem::ManuallyDrop<PM_INSTALLINFO>) -> ::windows::runtime::HRESULT,
4056     #[cfg(not(feature = "Win32_Foundation"))] usize,
4057     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pupdateinfo: *const ::std::mem::ManuallyDrop<PM_UPDATEINFO_LEGACY>) -> ::windows::runtime::HRESULT,
4058     #[cfg(not(feature = "Win32_Foundation"))] usize,
4059     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4060     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstallinfo: *const ::std::mem::ManuallyDrop<PM_INSTALLINFO>) -> ::windows::runtime::HRESULT,
4061     #[cfg(not(feature = "Win32_Foundation"))] usize,
4062     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pupdateinfo: *const ::std::mem::ManuallyDrop<PM_UPDATEINFO>) -> ::windows::runtime::HRESULT,
4063     #[cfg(not(feature = "Win32_Foundation"))] usize,
4064     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, offerid: ::windows::runtime::GUID, pblicense: *const u8, cblicense: u32) -> ::windows::runtime::HRESULT,
4065     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, packagepath: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppbchallenge: *mut *mut u8, pcbchallenge: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::HRESULT,
4066     #[cfg(not(feature = "Win32_Foundation"))] usize,
4067     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, ppbchallenge: *mut *mut u8, pcblicense: *mut u32) -> ::windows::runtime::HRESULT,
4068     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, ppbchallenge: *mut *mut u8, pcblicense: *mut u32, ppbkid: *mut *mut u8, pcbkid: *mut u32, ppbdeviceid: *mut *mut u8, pcbdeviceid: *mut u32, ppbsaltvalue: *mut *mut u8, pcbsaltvalue: *mut u32, ppbkgvvalue: *mut *mut u8, pcbkgvvalue: *mut u32) -> ::windows::runtime::HRESULT,
4069     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4070     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, filenames: *const super::Com::SAFEARRAY) -> ::windows::runtime::HRESULT,
4071     #[cfg(not(feature = "Win32_System_Com"))] usize,
4072     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, instanceid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4073     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, assemblypaths: *const super::Com::SAFEARRAY) -> ::windows::runtime::HRESULT,
4074     #[cfg(not(feature = "Win32_System_Com"))] usize,
4075     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4076     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, xmlpath: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4077     #[cfg(not(feature = "Win32_Foundation"))] usize,
4078     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4079     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4080     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, requiredmaintenanceoperations: u32, pcapplications: *mut u32) -> ::windows::runtime::HRESULT,
4081     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4082     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, publishername: super::super::Foundation::PWSTR, pisallowed: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4083     #[cfg(not(feature = "Win32_Foundation"))] usize,
4084     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pupdateinfo: *const ::std::mem::ManuallyDrop<PM_UPDATEINFO>) -> ::windows::runtime::HRESULT,
4085     #[cfg(not(feature = "Win32_Foundation"))] usize,
4086     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4087     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, resourcestring: super::super::Foundation::PWSTR, presolvedresourcestring: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4088     #[cfg(not(feature = "Win32_Foundation"))] usize,
4089     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4090     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4091     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, removaloptions: u32) -> ::windows::runtime::HRESULT,
4092     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4093     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, packagefamilyname: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4094     #[cfg(not(feature = "Win32_Foundation"))] usize,
4095     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, pblicense: *const u8, cblicense: u32, pbplayreadyheader: *const u8, cbplayreadyheader: u32) -> ::windows::runtime::HRESULT,
4096     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4097 );
4098 #[repr(transparent)]
4099 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4100 pub struct IPMEnumerationManager(::windows::runtime::IUnknown);
4101 impl IPMEnumerationManager {
4102     #[cfg(feature = "Win32_Foundation")]
AllApplications<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppappenum: *mut ::std::option::Option<IPMApplicationInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4103     pub unsafe fn AllApplications<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppappenum: *mut ::std::option::Option<IPMApplicationInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4104         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppappenum), filter.into_param().abi()).ok()
4105     }
4106     #[cfg(feature = "Win32_Foundation")]
AllTiles<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, pptileenum: *mut ::std::option::Option<IPMTileInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4107     pub unsafe fn AllTiles<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, pptileenum: *mut ::std::option::Option<IPMTileInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4108         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(pptileenum), filter.into_param().abi()).ok()
4109     }
4110     #[cfg(feature = "Win32_Foundation")]
AllTasks<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, pptaskenum: *mut ::std::option::Option<IPMTaskInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4111     pub unsafe fn AllTasks<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, pptaskenum: *mut ::std::option::Option<IPMTaskInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4112         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(pptaskenum), filter.into_param().abi()).ok()
4113     }
4114     #[cfg(feature = "Win32_Foundation")]
AllExtensions<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppextensionenum: *mut ::std::option::Option<IPMExtensionInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4115     pub unsafe fn AllExtensions<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppextensionenum: *mut ::std::option::Option<IPMExtensionInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4116         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppextensionenum), filter.into_param().abi()).ok()
4117     }
4118     #[cfg(feature = "Win32_Foundation")]
AllBackgroundServiceAgents<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppbsaenum: *mut ::std::option::Option<IPMBackgroundServiceAgentInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4119     pub unsafe fn AllBackgroundServiceAgents<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppbsaenum: *mut ::std::option::Option<IPMBackgroundServiceAgentInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4120         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppbsaenum), filter.into_param().abi()).ok()
4121     }
4122     #[cfg(feature = "Win32_Foundation")]
AllBackgroundWorkers<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppbswenum: *mut ::std::option::Option<IPMBackgroundWorkerInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()>4123     pub unsafe fn AllBackgroundWorkers<'a, Param1: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, ppbswenum: *mut ::std::option::Option<IPMBackgroundWorkerInfoEnumerator>, filter: Param1) -> ::windows::runtime::Result<()> {
4124         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppbswenum), filter.into_param().abi()).ok()
4125     }
ApplicationInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<IPMApplicationInfo>4126     pub unsafe fn ApplicationInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<IPMApplicationInfo> {
4127         let mut result__: <IPMApplicationInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4128         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), productid.into_param().abi(), &mut result__).from_abi::<IPMApplicationInfo>(result__)
4129     }
4130     #[cfg(feature = "Win32_Foundation")]
TileInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, tileid: Param1) -> ::windows::runtime::Result<IPMTileInfo>4131     pub unsafe fn TileInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, tileid: Param1) -> ::windows::runtime::Result<IPMTileInfo> {
4132         let mut result__: <IPMTileInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4133         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), productid.into_param().abi(), tileid.into_param().abi(), &mut result__).from_abi::<IPMTileInfo>(result__)
4134     }
4135     #[cfg(feature = "Win32_Foundation")]
TaskInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, taskid: Param1) -> ::windows::runtime::Result<IPMTaskInfo>4136     pub unsafe fn TaskInfo<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, taskid: Param1) -> ::windows::runtime::Result<IPMTaskInfo> {
4137         let mut result__: <IPMTaskInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4138         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), productid.into_param().abi(), taskid.into_param().abi(), &mut result__).from_abi::<IPMTaskInfo>(result__)
4139     }
4140     #[cfg(feature = "Win32_Foundation")]
TaskInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, productid: Param0, taskid: Param1) -> ::windows::runtime::Result<IPMTaskInfo>4141     pub unsafe fn TaskInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, productid: Param0, taskid: Param1) -> ::windows::runtime::Result<IPMTaskInfo> {
4142         let mut result__: <IPMTaskInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4143         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), productid.into_param().abi(), taskid.into_param().abi(), &mut result__).from_abi::<IPMTaskInfo>(result__)
4144     }
BackgroundServiceAgentInfo(&self, bsaid: u32) -> ::windows::runtime::Result<IPMBackgroundServiceAgentInfo>4145     pub unsafe fn BackgroundServiceAgentInfo(&self, bsaid: u32) -> ::windows::runtime::Result<IPMBackgroundServiceAgentInfo> {
4146         let mut result__: <IPMBackgroundServiceAgentInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4147         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(bsaid), &mut result__).from_abi::<IPMBackgroundServiceAgentInfo>(result__)
4148     }
AllLiveTileJobs(&self) -> ::windows::runtime::Result<IPMLiveTileJobInfoEnumerator>4149     pub unsafe fn AllLiveTileJobs(&self) -> ::windows::runtime::Result<IPMLiveTileJobInfoEnumerator> {
4150         let mut result__: <IPMLiveTileJobInfoEnumerator as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4151         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMLiveTileJobInfoEnumerator>(result__)
4152     }
4153     #[cfg(feature = "Win32_Foundation")]
LiveTileJob<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, tileid: Param1, recurrencetype: PM_LIVETILE_RECURRENCE_TYPE) -> ::windows::runtime::Result<IPMLiveTileJobInfo>4154     pub unsafe fn LiveTileJob<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, productid: Param0, tileid: Param1, recurrencetype: PM_LIVETILE_RECURRENCE_TYPE) -> ::windows::runtime::Result<IPMLiveTileJobInfo> {
4155         let mut result__: <IPMLiveTileJobInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4156         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), productid.into_param().abi(), tileid.into_param().abi(), ::std::mem::transmute(recurrencetype), &mut result__).from_abi::<IPMLiveTileJobInfo>(result__)
4157     }
ApplicationInfoExternal<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<IPMApplicationInfo>4158     pub unsafe fn ApplicationInfoExternal<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(&self, productid: Param0) -> ::windows::runtime::Result<IPMApplicationInfo> {
4159         let mut result__: <IPMApplicationInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4160         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), productid.into_param().abi(), &mut result__).from_abi::<IPMApplicationInfo>(result__)
4161     }
4162     #[cfg(feature = "Win32_Foundation")]
FileHandlerGenericLogo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filetype: Param0, logosize: PM_LOGO_SIZE, plogo: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4163     pub unsafe fn FileHandlerGenericLogo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filetype: Param0, logosize: PM_LOGO_SIZE, plogo: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4164         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), filetype.into_param().abi(), ::std::mem::transmute(logosize), ::std::mem::transmute(plogo)).ok()
4165     }
4166     #[cfg(feature = "Win32_Foundation")]
ApplicationInfoFromAccessClaims<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, sysappid0: Param0, sysappid1: Param1) -> ::windows::runtime::Result<IPMApplicationInfo>4167     pub unsafe fn ApplicationInfoFromAccessClaims<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, sysappid0: Param0, sysappid1: Param1) -> ::windows::runtime::Result<IPMApplicationInfo> {
4168         let mut result__: <IPMApplicationInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4169         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), sysappid0.into_param().abi(), sysappid1.into_param().abi(), &mut result__).from_abi::<IPMApplicationInfo>(result__)
4170     }
4171     #[cfg(feature = "Win32_Foundation")]
StartTileEnumeratorBlob<'a, Param0: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, filter: Param0, pctiles: *mut u32, pptileblobs: *mut *mut PM_STARTTILEBLOB) -> ::windows::runtime::Result<()>4172     pub unsafe fn StartTileEnumeratorBlob<'a, Param0: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, filter: Param0, pctiles: *mut u32, pptileblobs: *mut *mut PM_STARTTILEBLOB) -> ::windows::runtime::Result<()> {
4173         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), filter.into_param().abi(), ::std::mem::transmute(pctiles), ::std::mem::transmute(pptileblobs)).ok()
4174     }
4175     #[cfg(feature = "Win32_Foundation")]
StartAppEnumeratorBlob<'a, Param0: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, filter: Param0, pcapps: *mut u32, ppappblobs: *mut *mut PM_STARTAPPBLOB) -> ::windows::runtime::Result<()>4176     pub unsafe fn StartAppEnumeratorBlob<'a, Param0: ::windows::runtime::IntoParam<'a, PM_ENUM_FILTER>>(&self, filter: Param0, pcapps: *mut u32, ppappblobs: *mut *mut PM_STARTAPPBLOB) -> ::windows::runtime::Result<()> {
4177         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), filter.into_param().abi(), ::std::mem::transmute(pcapps), ::std::mem::transmute(ppappblobs)).ok()
4178     }
4179 }
4180 unsafe impl ::windows::runtime::Interface for IPMEnumerationManager {
4181     type Vtable = IPMEnumerationManager_abi;
4182     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1770870722, 10541, 19699, [183, 60, 217, 90, 105, 34, 237, 154]);
4183 }
4184 impl ::std::convert::From<IPMEnumerationManager> for ::windows::runtime::IUnknown {
from(value: IPMEnumerationManager) -> Self4185     fn from(value: IPMEnumerationManager) -> Self {
4186         unsafe { ::std::mem::transmute(value) }
4187     }
4188 }
4189 impl ::std::convert::From<&IPMEnumerationManager> for ::windows::runtime::IUnknown {
from(value: &IPMEnumerationManager) -> Self4190     fn from(value: &IPMEnumerationManager) -> Self {
4191         ::std::convert::From::from(::std::clone::Clone::clone(value))
4192     }
4193 }
4194 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMEnumerationManager {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4195     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4196         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4197     }
4198 }
4199 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMEnumerationManager {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4200     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4201         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4202     }
4203 }
4204 #[repr(C)]
4205 #[doc(hidden)]
4206 pub struct IPMEnumerationManager_abi(
4207     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4208     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4209     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4210     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppappenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4211     #[cfg(not(feature = "Win32_Foundation"))] usize,
4212     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pptileenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4213     #[cfg(not(feature = "Win32_Foundation"))] usize,
4214     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pptaskenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4215     #[cfg(not(feature = "Win32_Foundation"))] usize,
4216     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppextensionenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4217     #[cfg(not(feature = "Win32_Foundation"))] usize,
4218     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppbsaenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4219     #[cfg(not(feature = "Win32_Foundation"))] usize,
4220     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppbswenum: *mut ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>) -> ::windows::runtime::HRESULT,
4221     #[cfg(not(feature = "Win32_Foundation"))] usize,
4222     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, ppappinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4223     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, tileid: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pptileinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4224     #[cfg(not(feature = "Win32_Foundation"))] usize,
4225     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, taskid: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pptaskinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4226     #[cfg(not(feature = "Win32_Foundation"))] usize,
4227     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, taskid: super::super::Foundation::PWSTR, pptaskinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4228     #[cfg(not(feature = "Win32_Foundation"))] usize,
4229     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bsaid: u32, pptaskinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4230     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pplivetilejobenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4231     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, tileid: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, recurrencetype: PM_LIVETILE_RECURRENCE_TYPE, pplivetilejobinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4232     #[cfg(not(feature = "Win32_Foundation"))] usize,
4233     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, productid: ::windows::runtime::GUID, ppappinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4234     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, filetype: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, logosize: PM_LOGO_SIZE, plogo: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4235     #[cfg(not(feature = "Win32_Foundation"))] usize,
4236     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, sysappid0: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, sysappid1: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, ppappinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4237     #[cfg(not(feature = "Win32_Foundation"))] usize,
4238     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>, pctiles: *mut u32, pptileblobs: *mut *mut PM_STARTTILEBLOB) -> ::windows::runtime::HRESULT,
4239     #[cfg(not(feature = "Win32_Foundation"))] usize,
4240     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, filter: ::std::mem::ManuallyDrop<PM_ENUM_FILTER>, pcapps: *mut u32, ppappblobs: *mut *mut PM_STARTAPPBLOB) -> ::windows::runtime::HRESULT,
4241     #[cfg(not(feature = "Win32_Foundation"))] usize,
4242 );
4243 #[repr(transparent)]
4244 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4245 pub struct IPMExtensionCachedFileUpdaterInfo(::windows::runtime::IUnknown);
4246 impl IPMExtensionCachedFileUpdaterInfo {
4247     #[cfg(feature = "Win32_Foundation")]
SupportsUpdates(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4248     pub unsafe fn SupportsUpdates(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4249         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4250         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4251     }
4252 }
4253 unsafe impl ::windows::runtime::Interface for IPMExtensionCachedFileUpdaterInfo {
4254     type Vtable = IPMExtensionCachedFileUpdaterInfo_abi;
4255     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3805771017, 20056, 19369, [175, 126, 182, 66, 227, 112, 225, 176]);
4256 }
4257 impl ::std::convert::From<IPMExtensionCachedFileUpdaterInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionCachedFileUpdaterInfo) -> Self4258     fn from(value: IPMExtensionCachedFileUpdaterInfo) -> Self {
4259         unsafe { ::std::mem::transmute(value) }
4260     }
4261 }
4262 impl ::std::convert::From<&IPMExtensionCachedFileUpdaterInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionCachedFileUpdaterInfo) -> Self4263     fn from(value: &IPMExtensionCachedFileUpdaterInfo) -> Self {
4264         ::std::convert::From::from(::std::clone::Clone::clone(value))
4265     }
4266 }
4267 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionCachedFileUpdaterInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4268     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4269         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4270     }
4271 }
4272 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionCachedFileUpdaterInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4273     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4274         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4275     }
4276 }
4277 #[repr(C)]
4278 #[doc(hidden)]
4279 pub struct IPMExtensionCachedFileUpdaterInfo_abi(
4280     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4281     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4282     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4283     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psupportsupdates: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4284     #[cfg(not(feature = "Win32_Foundation"))] usize,
4285 );
4286 #[repr(transparent)]
4287 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4288 pub struct IPMExtensionContractInfo(::windows::runtime::IUnknown);
4289 impl IPMExtensionContractInfo {
4290     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, paumid: *mut super::super::Foundation::BSTR, pargs: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4291     pub unsafe fn InvocationInfo(&self, paumid: *mut super::super::Foundation::BSTR, pargs: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4292         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(paumid), ::std::mem::transmute(pargs)).ok()
4293     }
4294 }
4295 unsafe impl ::windows::runtime::Interface for IPMExtensionContractInfo {
4296     type Vtable = IPMExtensionContractInfo_abi;
4297     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3848692595, 31649, 18044, [184, 25, 177, 117, 219, 28, 41, 91]);
4298 }
4299 impl ::std::convert::From<IPMExtensionContractInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionContractInfo) -> Self4300     fn from(value: IPMExtensionContractInfo) -> Self {
4301         unsafe { ::std::mem::transmute(value) }
4302     }
4303 }
4304 impl ::std::convert::From<&IPMExtensionContractInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionContractInfo) -> Self4305     fn from(value: &IPMExtensionContractInfo) -> Self {
4306         ::std::convert::From::from(::std::clone::Clone::clone(value))
4307     }
4308 }
4309 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionContractInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4310     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4311         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4312     }
4313 }
4314 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionContractInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4315     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4316         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4317     }
4318 }
4319 #[repr(C)]
4320 #[doc(hidden)]
4321 pub struct IPMExtensionContractInfo_abi(
4322     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4323     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4324     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4325     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, paumid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pargs: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4326     #[cfg(not(feature = "Win32_Foundation"))] usize,
4327 );
4328 #[repr(transparent)]
4329 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4330 pub struct IPMExtensionFileExtensionInfo(::windows::runtime::IUnknown);
4331 impl IPMExtensionFileExtensionInfo {
4332     #[cfg(feature = "Win32_Foundation")]
Name(&self, pname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4333     pub unsafe fn Name(&self, pname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4334         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pname)).ok()
4335     }
4336     #[cfg(feature = "Win32_Foundation")]
DisplayName(&self, pdisplayname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4337     pub unsafe fn DisplayName(&self, pdisplayname: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4338         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdisplayname)).ok()
4339     }
4340     #[cfg(feature = "Win32_Foundation")]
Logo(&self, logosize: PM_LOGO_SIZE, plogo: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4341     pub unsafe fn Logo(&self, logosize: PM_LOGO_SIZE, plogo: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4342         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(logosize), ::std::mem::transmute(plogo)).ok()
4343     }
4344     #[cfg(feature = "Win32_Foundation")]
ContentType<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filetype: Param0, pcontenttype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4345     pub unsafe fn ContentType<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filetype: Param0, pcontenttype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4346         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), filetype.into_param().abi(), ::std::mem::transmute(pcontenttype)).ok()
4347     }
4348     #[cfg(feature = "Win32_Foundation")]
FileType<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, contenttype: Param0, pfiletype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4349     pub unsafe fn FileType<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, contenttype: Param0, pfiletype: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4350         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), contenttype.into_param().abi(), ::std::mem::transmute(pfiletype)).ok()
4351     }
4352     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4353     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4354         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
4355     }
4356     #[cfg(feature = "Win32_Foundation")]
AllFileTypes(&self, pcbtypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4357     pub unsafe fn AllFileTypes(&self, pcbtypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4358         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pcbtypes), ::std::mem::transmute(pptypes)).ok()
4359     }
4360 }
4361 unsafe impl ::windows::runtime::Interface for IPMExtensionFileExtensionInfo {
4362     type Vtable = IPMExtensionFileExtensionInfo_abi;
4363     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1804061548, 2952, 18825, [164, 236, 3, 55, 20, 247, 16, 212]);
4364 }
4365 impl ::std::convert::From<IPMExtensionFileExtensionInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionFileExtensionInfo) -> Self4366     fn from(value: IPMExtensionFileExtensionInfo) -> Self {
4367         unsafe { ::std::mem::transmute(value) }
4368     }
4369 }
4370 impl ::std::convert::From<&IPMExtensionFileExtensionInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionFileExtensionInfo) -> Self4371     fn from(value: &IPMExtensionFileExtensionInfo) -> Self {
4372         ::std::convert::From::from(::std::clone::Clone::clone(value))
4373     }
4374 }
4375 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionFileExtensionInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4376     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4377         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4378     }
4379 }
4380 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionFileExtensionInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4381     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4382         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4383     }
4384 }
4385 #[repr(C)]
4386 #[doc(hidden)]
4387 pub struct IPMExtensionFileExtensionInfo_abi(
4388     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4389     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4390     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4391     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pname: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4392     #[cfg(not(feature = "Win32_Foundation"))] usize,
4393     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdisplayname: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4394     #[cfg(not(feature = "Win32_Foundation"))] usize,
4395     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, logosize: PM_LOGO_SIZE, plogo: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4396     #[cfg(not(feature = "Win32_Foundation"))] usize,
4397     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, filetype: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pcontenttype: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4398     #[cfg(not(feature = "Win32_Foundation"))] usize,
4399     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, contenttype: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pfiletype: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4400     #[cfg(not(feature = "Win32_Foundation"))] usize,
4401     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4402     #[cfg(not(feature = "Win32_Foundation"))] usize,
4403     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pcbtypes: *mut u32, pptypes: *mut *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4404     #[cfg(not(feature = "Win32_Foundation"))] usize,
4405 );
4406 #[repr(transparent)]
4407 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4408 pub struct IPMExtensionFileOpenPickerInfo(::windows::runtime::IUnknown);
4409 impl IPMExtensionFileOpenPickerInfo {
4410     #[cfg(feature = "Win32_Foundation")]
AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4411     pub unsafe fn AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4412         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pctypes), ::std::mem::transmute(pptypes)).ok()
4413     }
4414     #[cfg(feature = "Win32_Foundation")]
SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4415     pub unsafe fn SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4416         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4417         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4418     }
4419 }
4420 unsafe impl ::windows::runtime::Interface for IPMExtensionFileOpenPickerInfo {
4421     type Vtable = IPMExtensionFileOpenPickerInfo_abi;
4422     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1841896741, 38406, 16908, [154, 120, 224, 52, 163, 65, 131, 69]);
4423 }
4424 impl ::std::convert::From<IPMExtensionFileOpenPickerInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionFileOpenPickerInfo) -> Self4425     fn from(value: IPMExtensionFileOpenPickerInfo) -> Self {
4426         unsafe { ::std::mem::transmute(value) }
4427     }
4428 }
4429 impl ::std::convert::From<&IPMExtensionFileOpenPickerInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionFileOpenPickerInfo) -> Self4430     fn from(value: &IPMExtensionFileOpenPickerInfo) -> Self {
4431         ::std::convert::From::from(::std::clone::Clone::clone(value))
4432     }
4433 }
4434 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionFileOpenPickerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4435     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4436         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4437     }
4438 }
4439 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionFileOpenPickerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4440     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4441         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4442     }
4443 }
4444 #[repr(C)]
4445 #[doc(hidden)]
4446 pub struct IPMExtensionFileOpenPickerInfo_abi(
4447     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4448     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4449     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4450     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctypes: *mut u32, pptypes: *mut *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4451     #[cfg(not(feature = "Win32_Foundation"))] usize,
4452     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psupportsalltypes: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4453     #[cfg(not(feature = "Win32_Foundation"))] usize,
4454 );
4455 #[repr(transparent)]
4456 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4457 pub struct IPMExtensionFileSavePickerInfo(::windows::runtime::IUnknown);
4458 impl IPMExtensionFileSavePickerInfo {
4459     #[cfg(feature = "Win32_Foundation")]
AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4460     pub unsafe fn AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4461         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pctypes), ::std::mem::transmute(pptypes)).ok()
4462     }
4463     #[cfg(feature = "Win32_Foundation")]
SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4464     pub unsafe fn SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4465         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4466         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4467     }
4468 }
4469 unsafe impl ::windows::runtime::Interface for IPMExtensionFileSavePickerInfo {
4470     type Vtable = IPMExtensionFileSavePickerInfo_abi;
4471     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(939547834, 63514, 18750, [160, 248, 146, 44, 134, 128, 218, 67]);
4472 }
4473 impl ::std::convert::From<IPMExtensionFileSavePickerInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionFileSavePickerInfo) -> Self4474     fn from(value: IPMExtensionFileSavePickerInfo) -> Self {
4475         unsafe { ::std::mem::transmute(value) }
4476     }
4477 }
4478 impl ::std::convert::From<&IPMExtensionFileSavePickerInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionFileSavePickerInfo) -> Self4479     fn from(value: &IPMExtensionFileSavePickerInfo) -> Self {
4480         ::std::convert::From::from(::std::clone::Clone::clone(value))
4481     }
4482 }
4483 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionFileSavePickerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4484     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4485         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4486     }
4487 }
4488 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionFileSavePickerInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4489     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4490         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4491     }
4492 }
4493 #[repr(C)]
4494 #[doc(hidden)]
4495 pub struct IPMExtensionFileSavePickerInfo_abi(
4496     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4497     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4498     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4499     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctypes: *mut u32, pptypes: *mut *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4500     #[cfg(not(feature = "Win32_Foundation"))] usize,
4501     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psupportsalltypes: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4502     #[cfg(not(feature = "Win32_Foundation"))] usize,
4503 );
4504 #[repr(transparent)]
4505 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4506 pub struct IPMExtensionInfo(::windows::runtime::IUnknown);
4507 impl IPMExtensionInfo {
SupplierPID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>4508     pub unsafe fn SupplierPID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
4509         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4510         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
4511     }
4512     #[cfg(feature = "Win32_Foundation")]
SupplierTaskID(&self, psuppliertid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4513     pub unsafe fn SupplierTaskID(&self, psuppliertid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4514         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(psuppliertid)).ok()
4515     }
4516     #[cfg(feature = "Win32_Foundation")]
Title(&self, ptitle: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4517     pub unsafe fn Title(&self, ptitle: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4518         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptitle)).ok()
4519     }
4520     #[cfg(feature = "Win32_Foundation")]
IconPath(&self, piconpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4521     pub unsafe fn IconPath(&self, piconpath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4522         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(piconpath)).ok()
4523     }
4524     #[cfg(feature = "Win32_Foundation")]
ExtraFile(&self, pfilepath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4525     pub unsafe fn ExtraFile(&self, pfilepath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4526         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(pfilepath)).ok()
4527     }
4528     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4529     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4530         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
4531     }
4532 }
4533 unsafe impl ::windows::runtime::Interface for IPMExtensionInfo {
4534     type Vtable = IPMExtensionInfo_abi;
4535     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1236065913, 38792, 19722, [138, 160, 23, 70, 175, 219, 158, 157]);
4536 }
4537 impl ::std::convert::From<IPMExtensionInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionInfo) -> Self4538     fn from(value: IPMExtensionInfo) -> Self {
4539         unsafe { ::std::mem::transmute(value) }
4540     }
4541 }
4542 impl ::std::convert::From<&IPMExtensionInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionInfo) -> Self4543     fn from(value: &IPMExtensionInfo) -> Self {
4544         ::std::convert::From::from(::std::clone::Clone::clone(value))
4545     }
4546 }
4547 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4548     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4549         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4550     }
4551 }
4552 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4553     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4554         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4555     }
4556 }
4557 #[repr(C)]
4558 #[doc(hidden)]
4559 pub struct IPMExtensionInfo_abi(
4560     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4561     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4562     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4563     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psupplierpid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4564     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psuppliertid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4565     #[cfg(not(feature = "Win32_Foundation"))] usize,
4566     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptitle: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4567     #[cfg(not(feature = "Win32_Foundation"))] usize,
4568     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, piconpath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4569     #[cfg(not(feature = "Win32_Foundation"))] usize,
4570     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pfilepath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4571     #[cfg(not(feature = "Win32_Foundation"))] usize,
4572     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4573     #[cfg(not(feature = "Win32_Foundation"))] usize,
4574 );
4575 #[repr(transparent)]
4576 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4577 pub struct IPMExtensionInfoEnumerator(::windows::runtime::IUnknown);
4578 impl IPMExtensionInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMExtensionInfo>4579     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMExtensionInfo> {
4580         let mut result__: <IPMExtensionInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4581         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMExtensionInfo>(result__)
4582     }
4583 }
4584 unsafe impl ::windows::runtime::Interface for IPMExtensionInfoEnumerator {
4585     type Vtable = IPMExtensionInfoEnumerator_abi;
4586     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1077649026, 4465, 17779, [142, 111, 111, 51, 243, 155, 131, 221]);
4587 }
4588 impl ::std::convert::From<IPMExtensionInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMExtensionInfoEnumerator) -> Self4589     fn from(value: IPMExtensionInfoEnumerator) -> Self {
4590         unsafe { ::std::mem::transmute(value) }
4591     }
4592 }
4593 impl ::std::convert::From<&IPMExtensionInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionInfoEnumerator) -> Self4594     fn from(value: &IPMExtensionInfoEnumerator) -> Self {
4595         ::std::convert::From::from(::std::clone::Clone::clone(value))
4596     }
4597 }
4598 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4599     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4600         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4601     }
4602 }
4603 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4604     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4605         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4606     }
4607 }
4608 #[repr(C)]
4609 #[doc(hidden)]
4610 pub struct IPMExtensionInfoEnumerator_abi(
4611     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4612     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4613     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4614     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppextensioninfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4615 );
4616 #[repr(transparent)]
4617 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4618 pub struct IPMExtensionProtocolInfo(::windows::runtime::IUnknown);
4619 impl IPMExtensionProtocolInfo {
4620     #[cfg(feature = "Win32_Foundation")]
Protocol(&self, pprotocol: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4621     pub unsafe fn Protocol(&self, pprotocol: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4622         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pprotocol)).ok()
4623     }
4624     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4625     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4626         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
4627     }
4628 }
4629 unsafe impl ::windows::runtime::Interface for IPMExtensionProtocolInfo {
4630     type Vtable = IPMExtensionProtocolInfo_abi;
4631     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(507486262, 20971, 17491, [186, 255, 184, 216, 228, 180, 108, 142]);
4632 }
4633 impl ::std::convert::From<IPMExtensionProtocolInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionProtocolInfo) -> Self4634     fn from(value: IPMExtensionProtocolInfo) -> Self {
4635         unsafe { ::std::mem::transmute(value) }
4636     }
4637 }
4638 impl ::std::convert::From<&IPMExtensionProtocolInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionProtocolInfo) -> Self4639     fn from(value: &IPMExtensionProtocolInfo) -> Self {
4640         ::std::convert::From::from(::std::clone::Clone::clone(value))
4641     }
4642 }
4643 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionProtocolInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4644     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4645         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4646     }
4647 }
4648 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionProtocolInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4649     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4650         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4651     }
4652 }
4653 #[repr(C)]
4654 #[doc(hidden)]
4655 pub struct IPMExtensionProtocolInfo_abi(
4656     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4657     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4658     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4659     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pprotocol: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4660     #[cfg(not(feature = "Win32_Foundation"))] usize,
4661     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4662     #[cfg(not(feature = "Win32_Foundation"))] usize,
4663 );
4664 #[repr(transparent)]
4665 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4666 pub struct IPMExtensionShareTargetInfo(::windows::runtime::IUnknown);
4667 impl IPMExtensionShareTargetInfo {
4668     #[cfg(feature = "Win32_Foundation")]
AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4669     pub unsafe fn AllFileTypes(&self, pctypes: *mut u32, pptypes: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4670         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(pctypes), ::std::mem::transmute(pptypes)).ok()
4671     }
4672     #[cfg(feature = "Win32_Foundation")]
AllDataFormats(&self, pcdataformats: *mut u32, ppdataformats: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4673     pub unsafe fn AllDataFormats(&self, pcdataformats: *mut u32, ppdataformats: *mut *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4674         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(pcdataformats), ::std::mem::transmute(ppdataformats)).ok()
4675     }
4676     #[cfg(feature = "Win32_Foundation")]
SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4677     pub unsafe fn SupportsAllFileTypes(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4678         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4679         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4680     }
4681 }
4682 unsafe impl ::windows::runtime::Interface for IPMExtensionShareTargetInfo {
4683     type Vtable = IPMExtensionShareTargetInfo_abi;
4684     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1416754315, 50780, 18006, [140, 112, 36, 46, 49, 25, 95, 234]);
4685 }
4686 impl ::std::convert::From<IPMExtensionShareTargetInfo> for ::windows::runtime::IUnknown {
from(value: IPMExtensionShareTargetInfo) -> Self4687     fn from(value: IPMExtensionShareTargetInfo) -> Self {
4688         unsafe { ::std::mem::transmute(value) }
4689     }
4690 }
4691 impl ::std::convert::From<&IPMExtensionShareTargetInfo> for ::windows::runtime::IUnknown {
from(value: &IPMExtensionShareTargetInfo) -> Self4692     fn from(value: &IPMExtensionShareTargetInfo) -> Self {
4693         ::std::convert::From::from(::std::clone::Clone::clone(value))
4694     }
4695 }
4696 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMExtensionShareTargetInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4697     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4698         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4699     }
4700 }
4701 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMExtensionShareTargetInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4702     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4703         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4704     }
4705 }
4706 #[repr(C)]
4707 #[doc(hidden)]
4708 pub struct IPMExtensionShareTargetInfo_abi(
4709     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4710     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4711     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4712     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctypes: *mut u32, pptypes: *mut *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4713     #[cfg(not(feature = "Win32_Foundation"))] usize,
4714     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pcdataformats: *mut u32, ppdataformats: *mut *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4715     #[cfg(not(feature = "Win32_Foundation"))] usize,
4716     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psupportsalltypes: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4717     #[cfg(not(feature = "Win32_Foundation"))] usize,
4718 );
4719 #[repr(transparent)]
4720 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4721 pub struct IPMLiveTileJobInfo(::windows::runtime::IUnknown);
4722 impl IPMLiveTileJobInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>4723     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
4724         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4725         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
4726     }
4727     #[cfg(feature = "Win32_Foundation")]
TileID(&self, ptileid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4728     pub unsafe fn TileID(&self, ptileid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4729         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptileid)).ok()
4730     }
4731     #[cfg(feature = "Win32_Foundation")]
NextSchedule(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME>4732     pub unsafe fn NextSchedule(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME> {
4733         let mut result__: <super::super::Foundation::FILETIME as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4734         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::FILETIME>(result__)
4735     }
4736     #[cfg(feature = "Win32_Foundation")]
set_NextSchedule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::FILETIME>>(&self, ftnextschedule: Param0) -> ::windows::runtime::Result<()>4737     pub unsafe fn set_NextSchedule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::FILETIME>>(&self, ftnextschedule: Param0) -> ::windows::runtime::Result<()> {
4738         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ftnextschedule.into_param().abi()).ok()
4739     }
4740     #[cfg(feature = "Win32_Foundation")]
StartSchedule(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME>4741     pub unsafe fn StartSchedule(&self) -> ::windows::runtime::Result<super::super::Foundation::FILETIME> {
4742         let mut result__: <super::super::Foundation::FILETIME as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4743         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::FILETIME>(result__)
4744     }
4745     #[cfg(feature = "Win32_Foundation")]
set_StartSchedule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::FILETIME>>(&self, ftstartschedule: Param0) -> ::windows::runtime::Result<()>4746     pub unsafe fn set_StartSchedule<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::FILETIME>>(&self, ftstartschedule: Param0) -> ::windows::runtime::Result<()> {
4747         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ftstartschedule.into_param().abi()).ok()
4748     }
IntervalDuration(&self) -> ::windows::runtime::Result<u32>4749     pub unsafe fn IntervalDuration(&self) -> ::windows::runtime::Result<u32> {
4750         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4751         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4752     }
set_IntervalDuration(&self, ulintervalduration: u32) -> ::windows::runtime::Result<()>4753     pub unsafe fn set_IntervalDuration(&self, ulintervalduration: u32) -> ::windows::runtime::Result<()> {
4754         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulintervalduration)).ok()
4755     }
4756     #[cfg(feature = "Win32_Foundation")]
RunForever(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4757     pub unsafe fn RunForever(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4758         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4759         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4760     }
4761     #[cfg(feature = "Win32_Foundation")]
set_RunForever<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, frunforever: Param0) -> ::windows::runtime::Result<()>4762     pub unsafe fn set_RunForever<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, frunforever: Param0) -> ::windows::runtime::Result<()> {
4763         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), frunforever.into_param().abi()).ok()
4764     }
MaxRunCount(&self) -> ::windows::runtime::Result<u32>4765     pub unsafe fn MaxRunCount(&self) -> ::windows::runtime::Result<u32> {
4766         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4767         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4768     }
set_MaxRunCount(&self, ulmaxruncount: u32) -> ::windows::runtime::Result<()>4769     pub unsafe fn set_MaxRunCount(&self, ulmaxruncount: u32) -> ::windows::runtime::Result<()> {
4770         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulmaxruncount)).ok()
4771     }
RunCount(&self) -> ::windows::runtime::Result<u32>4772     pub unsafe fn RunCount(&self) -> ::windows::runtime::Result<u32> {
4773         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4774         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4775     }
set_RunCount(&self, ulruncount: u32) -> ::windows::runtime::Result<()>4776     pub unsafe fn set_RunCount(&self, ulruncount: u32) -> ::windows::runtime::Result<()> {
4777         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulruncount)).ok()
4778     }
RecurrenceType(&self) -> ::windows::runtime::Result<u32>4779     pub unsafe fn RecurrenceType(&self) -> ::windows::runtime::Result<u32> {
4780         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4781         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4782     }
set_RecurrenceType(&self, ulrecurrencetype: u32) -> ::windows::runtime::Result<()>4783     pub unsafe fn set_RecurrenceType(&self, ulrecurrencetype: u32) -> ::windows::runtime::Result<()> {
4784         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulrecurrencetype)).ok()
4785     }
TileXML(&self, ptilexml: *mut *mut u8, pcbtilexml: *mut u32) -> ::windows::runtime::Result<()>4786     pub unsafe fn TileXML(&self, ptilexml: *mut *mut u8, pcbtilexml: *mut u32) -> ::windows::runtime::Result<()> {
4787         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptilexml), ::std::mem::transmute(pcbtilexml)).ok()
4788     }
set_TileXML(&self, ptilexml: *const u8, cbtilexml: u32) -> ::windows::runtime::Result<()>4789     pub unsafe fn set_TileXML(&self, ptilexml: *const u8, cbtilexml: u32) -> ::windows::runtime::Result<()> {
4790         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptilexml), ::std::mem::transmute(cbtilexml)).ok()
4791     }
UrlXML(&self, purlxml: *mut *mut u8, pcburlxml: *mut u32) -> ::windows::runtime::Result<()>4792     pub unsafe fn UrlXML(&self, purlxml: *mut *mut u8, pcburlxml: *mut u32) -> ::windows::runtime::Result<()> {
4793         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), ::std::mem::transmute(purlxml), ::std::mem::transmute(pcburlxml)).ok()
4794     }
set_UrlXML(&self, purlxml: *const u8, cburlxml: u32) -> ::windows::runtime::Result<()>4795     pub unsafe fn set_UrlXML(&self, purlxml: *const u8, cburlxml: u32) -> ::windows::runtime::Result<()> {
4796         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(purlxml), ::std::mem::transmute(cburlxml)).ok()
4797     }
AttemptCount(&self) -> ::windows::runtime::Result<u32>4798     pub unsafe fn AttemptCount(&self) -> ::windows::runtime::Result<u32> {
4799         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4800         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4801     }
set_AttemptCount(&self, ulattemptcount: u32) -> ::windows::runtime::Result<()>4802     pub unsafe fn set_AttemptCount(&self, ulattemptcount: u32) -> ::windows::runtime::Result<()> {
4803         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), ::std::mem::transmute(ulattemptcount)).ok()
4804     }
DownloadState(&self) -> ::windows::runtime::Result<u32>4805     pub unsafe fn DownloadState(&self) -> ::windows::runtime::Result<u32> {
4806         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4807         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4808     }
set_DownloadState(&self, uldownloadstate: u32) -> ::windows::runtime::Result<()>4809     pub unsafe fn set_DownloadState(&self, uldownloadstate: u32) -> ::windows::runtime::Result<()> {
4810         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), ::std::mem::transmute(uldownloadstate)).ok()
4811     }
4812 }
4813 unsafe impl ::windows::runtime::Interface for IPMLiveTileJobInfo {
4814     type Vtable = IPMLiveTileJobInfo_abi;
4815     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1611245599, 18192, 18071, [181, 246, 34, 8, 246, 5, 123, 142]);
4816 }
4817 impl ::std::convert::From<IPMLiveTileJobInfo> for ::windows::runtime::IUnknown {
from(value: IPMLiveTileJobInfo) -> Self4818     fn from(value: IPMLiveTileJobInfo) -> Self {
4819         unsafe { ::std::mem::transmute(value) }
4820     }
4821 }
4822 impl ::std::convert::From<&IPMLiveTileJobInfo> for ::windows::runtime::IUnknown {
from(value: &IPMLiveTileJobInfo) -> Self4823     fn from(value: &IPMLiveTileJobInfo) -> Self {
4824         ::std::convert::From::from(::std::clone::Clone::clone(value))
4825     }
4826 }
4827 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMLiveTileJobInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4828     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4829         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4830     }
4831 }
4832 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMLiveTileJobInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4833     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4834         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4835     }
4836 }
4837 #[repr(C)]
4838 #[doc(hidden)]
4839 pub struct IPMLiveTileJobInfo_abi(
4840     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4841     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4842     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4843     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
4844     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptileid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
4845     #[cfg(not(feature = "Win32_Foundation"))] usize,
4846     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnextschedule: *mut super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
4847     #[cfg(not(feature = "Win32_Foundation"))] usize,
4848     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ftnextschedule: super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
4849     #[cfg(not(feature = "Win32_Foundation"))] usize,
4850     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstartschedule: *mut super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
4851     #[cfg(not(feature = "Win32_Foundation"))] usize,
4852     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ftstartschedule: super::super::Foundation::FILETIME) -> ::windows::runtime::HRESULT,
4853     #[cfg(not(feature = "Win32_Foundation"))] usize,
4854     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pintervalduration: *mut u32) -> ::windows::runtime::HRESULT,
4855     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulintervalduration: u32) -> ::windows::runtime::HRESULT,
4856     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, isrunforever: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4857     #[cfg(not(feature = "Win32_Foundation"))] usize,
4858     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, frunforever: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4859     #[cfg(not(feature = "Win32_Foundation"))] usize,
4860     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pmaxruncount: *mut u32) -> ::windows::runtime::HRESULT,
4861     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulmaxruncount: u32) -> ::windows::runtime::HRESULT,
4862     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pruncount: *mut u32) -> ::windows::runtime::HRESULT,
4863     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulruncount: u32) -> ::windows::runtime::HRESULT,
4864     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, precurrencetype: *mut u32) -> ::windows::runtime::HRESULT,
4865     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulrecurrencetype: u32) -> ::windows::runtime::HRESULT,
4866     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptilexml: *mut *mut u8, pcbtilexml: *mut u32) -> ::windows::runtime::HRESULT,
4867     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptilexml: *const u8, cbtilexml: u32) -> ::windows::runtime::HRESULT,
4868     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, purlxml: *mut *mut u8, pcburlxml: *mut u32) -> ::windows::runtime::HRESULT,
4869     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, purlxml: *const u8, cburlxml: u32) -> ::windows::runtime::HRESULT,
4870     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pattemptcount: *mut u32) -> ::windows::runtime::HRESULT,
4871     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ulattemptcount: u32) -> ::windows::runtime::HRESULT,
4872     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdownloadstate: *mut u32) -> ::windows::runtime::HRESULT,
4873     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uldownloadstate: u32) -> ::windows::runtime::HRESULT,
4874 );
4875 #[repr(transparent)]
4876 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4877 pub struct IPMLiveTileJobInfoEnumerator(::windows::runtime::IUnknown);
4878 impl IPMLiveTileJobInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMLiveTileJobInfo>4879     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMLiveTileJobInfo> {
4880         let mut result__: <IPMLiveTileJobInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4881         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMLiveTileJobInfo>(result__)
4882     }
4883 }
4884 unsafe impl ::windows::runtime::Interface for IPMLiveTileJobInfoEnumerator {
4885     type Vtable = IPMLiveTileJobInfoEnumerator_abi;
4886     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3154388354, 37909, 20278, [159, 153, 6, 241, 4, 192, 124, 3]);
4887 }
4888 impl ::std::convert::From<IPMLiveTileJobInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMLiveTileJobInfoEnumerator) -> Self4889     fn from(value: IPMLiveTileJobInfoEnumerator) -> Self {
4890         unsafe { ::std::mem::transmute(value) }
4891     }
4892 }
4893 impl ::std::convert::From<&IPMLiveTileJobInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMLiveTileJobInfoEnumerator) -> Self4894     fn from(value: &IPMLiveTileJobInfoEnumerator) -> Self {
4895         ::std::convert::From::from(::std::clone::Clone::clone(value))
4896     }
4897 }
4898 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMLiveTileJobInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4899     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4900         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4901     }
4902 }
4903 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMLiveTileJobInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4904     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4905         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4906     }
4907 }
4908 #[repr(C)]
4909 #[doc(hidden)]
4910 pub struct IPMLiveTileJobInfoEnumerator_abi(
4911     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4912     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4913     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4914     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pplivetilejobinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4915 );
4916 #[repr(transparent)]
4917 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4918 pub struct IPMTaskInfo(::windows::runtime::IUnknown);
4919 impl IPMTaskInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>4920     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
4921         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4922         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
4923     }
4924     #[cfg(feature = "Win32_Foundation")]
TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4925     pub unsafe fn TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4926         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptaskid)).ok()
4927     }
4928     #[cfg(feature = "Win32_Foundation")]
NavigationPage(&self, pnavigationpage: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4929     pub unsafe fn NavigationPage(&self, pnavigationpage: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4930         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(pnavigationpage)).ok()
4931     }
TaskTransition(&self) -> ::windows::runtime::Result<PM_TASK_TRANSITION>4932     pub unsafe fn TaskTransition(&self) -> ::windows::runtime::Result<PM_TASK_TRANSITION> {
4933         let mut result__: <PM_TASK_TRANSITION as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4934         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_TASK_TRANSITION>(result__)
4935     }
RuntimeType(&self) -> ::windows::runtime::Result<PACKMAN_RUNTIME>4936     pub unsafe fn RuntimeType(&self) -> ::windows::runtime::Result<PACKMAN_RUNTIME> {
4937         let mut result__: <PACKMAN_RUNTIME as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4938         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PACKMAN_RUNTIME>(result__)
4939     }
ActivationPolicy(&self) -> ::windows::runtime::Result<PM_ACTIVATION_POLICY>4940     pub unsafe fn ActivationPolicy(&self) -> ::windows::runtime::Result<PM_ACTIVATION_POLICY> {
4941         let mut result__: <PM_ACTIVATION_POLICY as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4942         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_ACTIVATION_POLICY>(result__)
4943     }
TaskType(&self) -> ::windows::runtime::Result<PM_TASK_TYPE>4944     pub unsafe fn TaskType(&self) -> ::windows::runtime::Result<PM_TASK_TYPE> {
4945         let mut result__: <PM_TASK_TYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4946         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_TASK_TYPE>(result__)
4947     }
4948     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4949     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4950         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
4951     }
4952     #[cfg(feature = "Win32_Foundation")]
ImagePath(&self, pimagepath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4953     pub unsafe fn ImagePath(&self, pimagepath: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4954         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimagepath)).ok()
4955     }
4956     #[cfg(feature = "Win32_Foundation")]
ImageParams(&self, pimageparams: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4957     pub unsafe fn ImageParams(&self, pimageparams: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4958         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageparams)).ok()
4959     }
4960     #[cfg(feature = "Win32_Foundation")]
InstallRootFolder(&self, pinstallrootfolder: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4961     pub unsafe fn InstallRootFolder(&self, pinstallrootfolder: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4962         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(pinstallrootfolder)).ok()
4963     }
4964     #[cfg(feature = "Win32_Foundation")]
DataRootFolder(&self, pdatarootfolder: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4965     pub unsafe fn DataRootFolder(&self, pdatarootfolder: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
4966         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdatarootfolder)).ok()
4967     }
4968     #[cfg(feature = "Win32_Foundation")]
IsSingleInstanceHost(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4969     pub unsafe fn IsSingleInstanceHost(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4970         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4971         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4972     }
4973     #[cfg(feature = "Win32_Foundation")]
IsInteropEnabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4974     pub unsafe fn IsInteropEnabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4975         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4976         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4977     }
ApplicationState(&self) -> ::windows::runtime::Result<PM_APPLICATION_STATE>4978     pub unsafe fn ApplicationState(&self) -> ::windows::runtime::Result<PM_APPLICATION_STATE> {
4979         let mut result__: <PM_APPLICATION_STATE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4980         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_APPLICATION_STATE>(result__)
4981     }
InstallType(&self) -> ::windows::runtime::Result<PM_APPLICATION_INSTALL_TYPE>4982     pub unsafe fn InstallType(&self) -> ::windows::runtime::Result<PM_APPLICATION_INSTALL_TYPE> {
4983         let mut result__: <PM_APPLICATION_INSTALL_TYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4984         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_APPLICATION_INSTALL_TYPE>(result__)
4985     }
Version(&self, ptargetmajorversion: *mut u8, ptargetminorversion: *mut u8) -> ::windows::runtime::Result<()>4986     pub unsafe fn Version(&self, ptargetmajorversion: *mut u8, ptargetminorversion: *mut u8) -> ::windows::runtime::Result<()> {
4987         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptargetmajorversion), ::std::mem::transmute(ptargetminorversion)).ok()
4988     }
BitsPerPixel(&self) -> ::windows::runtime::Result<u16>4989     pub unsafe fn BitsPerPixel(&self) -> ::windows::runtime::Result<u16> {
4990         let mut result__: <u16 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4991         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u16>(result__)
4992     }
4993     #[cfg(feature = "Win32_Foundation")]
SuppressesDehydration(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>4994     pub unsafe fn SuppressesDehydration(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
4995         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4996         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
4997     }
4998     #[cfg(feature = "Win32_Foundation")]
BackgroundExecutionAbilities(&self, pbackgroundexecutionabilities: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>4999     pub unsafe fn BackgroundExecutionAbilities(&self, pbackgroundexecutionabilities: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
5000         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(pbackgroundexecutionabilities)).ok()
5001     }
5002     #[cfg(feature = "Win32_Foundation")]
IsOptedForExtendedMem(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5003     pub unsafe fn IsOptedForExtendedMem(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5004         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5005         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5006     }
5007 }
5008 unsafe impl ::windows::runtime::Interface for IPMTaskInfo {
5009     type Vtable = IPMTaskInfo_abi;
5010     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3206384691, 7157, 20192, [181, 73, 107, 157, 211, 131, 73, 66]);
5011 }
5012 impl ::std::convert::From<IPMTaskInfo> for ::windows::runtime::IUnknown {
from(value: IPMTaskInfo) -> Self5013     fn from(value: IPMTaskInfo) -> Self {
5014         unsafe { ::std::mem::transmute(value) }
5015     }
5016 }
5017 impl ::std::convert::From<&IPMTaskInfo> for ::windows::runtime::IUnknown {
from(value: &IPMTaskInfo) -> Self5018     fn from(value: &IPMTaskInfo) -> Self {
5019         ::std::convert::From::from(::std::clone::Clone::clone(value))
5020     }
5021 }
5022 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTaskInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5023     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5024         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5025     }
5026 }
5027 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTaskInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5028     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5029         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5030     }
5031 }
5032 #[repr(C)]
5033 #[doc(hidden)]
5034 pub struct IPMTaskInfo_abi(
5035     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5036     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5037     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5038     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
5039     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptaskid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5040     #[cfg(not(feature = "Win32_Foundation"))] usize,
5041     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnavigationpage: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5042     #[cfg(not(feature = "Win32_Foundation"))] usize,
5043     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptasktransition: *mut PM_TASK_TRANSITION) -> ::windows::runtime::HRESULT,
5044     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pruntimetype: *mut PACKMAN_RUNTIME) -> ::windows::runtime::HRESULT,
5045     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pactivationpolicy: *mut PM_ACTIVATION_POLICY) -> ::windows::runtime::HRESULT,
5046     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptasktype: *mut PM_TASK_TYPE) -> ::windows::runtime::HRESULT,
5047     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5048     #[cfg(not(feature = "Win32_Foundation"))] usize,
5049     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimagepath: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5050     #[cfg(not(feature = "Win32_Foundation"))] usize,
5051     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageparams: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5052     #[cfg(not(feature = "Win32_Foundation"))] usize,
5053     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstallrootfolder: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5054     #[cfg(not(feature = "Win32_Foundation"))] usize,
5055     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdatarootfolder: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5056     #[cfg(not(feature = "Win32_Foundation"))] usize,
5057     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pissingleinstancehost: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5058     #[cfg(not(feature = "Win32_Foundation"))] usize,
5059     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisinteropenabled: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5060     #[cfg(not(feature = "Win32_Foundation"))] usize,
5061     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, papplicationstate: *mut PM_APPLICATION_STATE) -> ::windows::runtime::HRESULT,
5062     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pinstalltype: *mut PM_APPLICATION_INSTALL_TYPE) -> ::windows::runtime::HRESULT,
5063     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptargetmajorversion: *mut u8, ptargetminorversion: *mut u8) -> ::windows::runtime::HRESULT,
5064     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbitsperpixel: *mut u16) -> ::windows::runtime::HRESULT,
5065     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psuppressesdehydration: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5066     #[cfg(not(feature = "Win32_Foundation"))] usize,
5067     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbackgroundexecutionabilities: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5068     #[cfg(not(feature = "Win32_Foundation"))] usize,
5069     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisoptedin: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5070     #[cfg(not(feature = "Win32_Foundation"))] usize,
5071 );
5072 #[repr(transparent)]
5073 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5074 pub struct IPMTaskInfoEnumerator(::windows::runtime::IUnknown);
5075 impl IPMTaskInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMTaskInfo>5076     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMTaskInfo> {
5077         let mut result__: <IPMTaskInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5078         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMTaskInfo>(result__)
5079     }
5080 }
5081 unsafe impl ::windows::runtime::Interface for IPMTaskInfoEnumerator {
5082     type Vtable = IPMTaskInfoEnumerator_abi;
5083     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(103854328, 3004, 18465, [190, 116, 199, 153, 81, 102, 237, 42]);
5084 }
5085 impl ::std::convert::From<IPMTaskInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMTaskInfoEnumerator) -> Self5086     fn from(value: IPMTaskInfoEnumerator) -> Self {
5087         unsafe { ::std::mem::transmute(value) }
5088     }
5089 }
5090 impl ::std::convert::From<&IPMTaskInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMTaskInfoEnumerator) -> Self5091     fn from(value: &IPMTaskInfoEnumerator) -> Self {
5092         ::std::convert::From::from(::std::clone::Clone::clone(value))
5093     }
5094 }
5095 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTaskInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5096     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5097         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5098     }
5099 }
5100 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTaskInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5101     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5102         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5103     }
5104 }
5105 #[repr(C)]
5106 #[doc(hidden)]
5107 pub struct IPMTaskInfoEnumerator_abi(
5108     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5109     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5110     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5111     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pptaskinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5112 );
5113 #[repr(transparent)]
5114 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5115 pub struct IPMTileInfo(::windows::runtime::IUnknown);
5116 impl IPMTileInfo {
ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID>5117     pub unsafe fn ProductID(&self) -> ::windows::runtime::Result<::windows::runtime::GUID> {
5118         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5119         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
5120     }
5121     #[cfg(feature = "Win32_Foundation")]
TileID(&self, ptileid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>5122     pub unsafe fn TileID(&self, ptileid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
5123         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptileid)).ok()
5124     }
TemplateType(&self) -> ::windows::runtime::Result<TILE_TEMPLATE_TYPE>5125     pub unsafe fn TemplateType(&self) -> ::windows::runtime::Result<TILE_TEMPLATE_TYPE> {
5126         let mut result__: <TILE_TEMPLATE_TYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5127         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<TILE_TEMPLATE_TYPE>(result__)
5128     }
5129     #[cfg(feature = "Win32_Foundation")]
HubPinnedState(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5130     pub unsafe fn HubPinnedState(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5131         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5132         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5133     }
HubPosition(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<u32>5134     pub unsafe fn HubPosition(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<u32> {
5135         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5136         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), &mut result__).from_abi::<u32>(result__)
5137     }
5138     #[cfg(feature = "Win32_Foundation")]
IsNotified(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5139     pub unsafe fn IsNotified(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5140         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5141         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5142     }
5143     #[cfg(feature = "Win32_Foundation")]
IsDefault(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5144     pub unsafe fn IsDefault(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5145         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5146         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5147     }
5148     #[cfg(feature = "Win32_Foundation")]
TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>5149     pub unsafe fn TaskID(&self, ptaskid: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
5150         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(ptaskid)).ok()
5151     }
TileType(&self) -> ::windows::runtime::Result<PM_STARTTILE_TYPE>5152     pub unsafe fn TileType(&self) -> ::windows::runtime::Result<PM_STARTTILE_TYPE> {
5153         let mut result__: <PM_STARTTILE_TYPE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5154         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<PM_STARTTILE_TYPE>(result__)
5155     }
5156     #[cfg(feature = "Win32_Foundation")]
IsThemable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5157     pub unsafe fn IsThemable(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5158         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5159         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5160     }
PropertyById(&self, propid: u32) -> ::windows::runtime::Result<IPMTilePropertyInfo>5161     pub unsafe fn PropertyById(&self, propid: u32) -> ::windows::runtime::Result<IPMTilePropertyInfo> {
5162         let mut result__: <IPMTilePropertyInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5163         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(propid), &mut result__).from_abi::<IPMTilePropertyInfo>(result__)
5164     }
5165     #[cfg(feature = "Win32_Foundation")]
InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>5166     pub unsafe fn InvocationInfo(&self, pimageurn: *mut super::super::Foundation::BSTR, pparameters: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
5167         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(pimageurn), ::std::mem::transmute(pparameters)).ok()
5168     }
PropertyEnum(&self) -> ::windows::runtime::Result<IPMTilePropertyEnumerator>5169     pub unsafe fn PropertyEnum(&self) -> ::windows::runtime::Result<IPMTilePropertyEnumerator> {
5170         let mut result__: <IPMTilePropertyEnumerator as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5171         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMTilePropertyEnumerator>(result__)
5172     }
HubTileSize(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<PM_TILE_SIZE>5173     pub unsafe fn HubTileSize(&self, hubtype: PM_TILE_HUBTYPE) -> ::windows::runtime::Result<PM_TILE_SIZE> {
5174         let mut result__: <PM_TILE_SIZE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5175         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), &mut result__).from_abi::<PM_TILE_SIZE>(result__)
5176     }
set_HubPosition(&self, hubtype: PM_TILE_HUBTYPE, position: u32) -> ::windows::runtime::Result<()>5177     pub unsafe fn set_HubPosition(&self, hubtype: PM_TILE_HUBTYPE, position: u32) -> ::windows::runtime::Result<()> {
5178         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), ::std::mem::transmute(position)).ok()
5179     }
5180     #[cfg(feature = "Win32_Foundation")]
set_NotifiedState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, notified: Param0) -> ::windows::runtime::Result<()>5181     pub unsafe fn set_NotifiedState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, notified: Param0) -> ::windows::runtime::Result<()> {
5182         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), notified.into_param().abi()).ok()
5183     }
5184     #[cfg(feature = "Win32_Foundation")]
set_HubPinnedState<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hubtype: PM_TILE_HUBTYPE, pinned: Param1) -> ::windows::runtime::Result<()>5185     pub unsafe fn set_HubPinnedState<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hubtype: PM_TILE_HUBTYPE, pinned: Param1) -> ::windows::runtime::Result<()> {
5186         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), pinned.into_param().abi()).ok()
5187     }
set_HubTileSize(&self, hubtype: PM_TILE_HUBTYPE, size: PM_TILE_SIZE) -> ::windows::runtime::Result<()>5188     pub unsafe fn set_HubTileSize(&self, hubtype: PM_TILE_HUBTYPE, size: PM_TILE_SIZE) -> ::windows::runtime::Result<()> {
5189         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), ::std::mem::transmute(hubtype), ::std::mem::transmute(size)).ok()
5190     }
5191     #[cfg(feature = "Win32_Foundation")]
set_InvocationInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, taskname: Param0, taskparameters: Param1) -> ::windows::runtime::Result<()>5192     pub unsafe fn set_InvocationInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, taskname: Param0, taskparameters: Param1) -> ::windows::runtime::Result<()> {
5193         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), taskname.into_param().abi(), taskparameters.into_param().abi()).ok()
5194     }
5195     #[cfg(feature = "Win32_Foundation")]
StartTileBlob(&self, pblob: *mut PM_STARTTILEBLOB) -> ::windows::runtime::Result<()>5196     pub unsafe fn StartTileBlob(&self, pblob: *mut PM_STARTTILEBLOB) -> ::windows::runtime::Result<()> {
5197         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(pblob)).ok()
5198     }
5199     #[cfg(feature = "Win32_Foundation")]
IsRestoring(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5200     pub unsafe fn IsRestoring(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5201         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5202         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5203     }
5204     #[cfg(feature = "Win32_Foundation")]
IsAutoRestoreDisabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL>5205     pub unsafe fn IsAutoRestoreDisabled(&self) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
5206         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5207         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
5208     }
5209     #[cfg(feature = "Win32_Foundation")]
set_IsRestoring<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, restoring: Param0) -> ::windows::runtime::Result<()>5210     pub unsafe fn set_IsRestoring<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, restoring: Param0) -> ::windows::runtime::Result<()> {
5211         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), restoring.into_param().abi()).ok()
5212     }
5213     #[cfg(feature = "Win32_Foundation")]
set_IsAutoRestoreDisabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, autorestoredisabled: Param0) -> ::windows::runtime::Result<()>5214     pub unsafe fn set_IsAutoRestoreDisabled<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(&self, autorestoredisabled: Param0) -> ::windows::runtime::Result<()> {
5215         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), autorestoredisabled.into_param().abi()).ok()
5216     }
5217 }
5218 unsafe impl ::windows::runtime::Interface for IPMTileInfo {
5219     type Vtable = IPMTileInfo_abi;
5220     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3512748083, 11016, 16385, [130, 205, 24, 58, 215, 52, 247, 82]);
5221 }
5222 impl ::std::convert::From<IPMTileInfo> for ::windows::runtime::IUnknown {
from(value: IPMTileInfo) -> Self5223     fn from(value: IPMTileInfo) -> Self {
5224         unsafe { ::std::mem::transmute(value) }
5225     }
5226 }
5227 impl ::std::convert::From<&IPMTileInfo> for ::windows::runtime::IUnknown {
from(value: &IPMTileInfo) -> Self5228     fn from(value: &IPMTileInfo) -> Self {
5229         ::std::convert::From::from(::std::clone::Clone::clone(value))
5230     }
5231 }
5232 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTileInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5233     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5234         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5235     }
5236 }
5237 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTileInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5238     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5239         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5240     }
5241 }
5242 #[repr(C)]
5243 #[doc(hidden)]
5244 pub struct IPMTileInfo_abi(
5245     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5246     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5247     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5248     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pproductid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT,
5249     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptileid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5250     #[cfg(not(feature = "Win32_Foundation"))] usize,
5251     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptemplatetype: *mut TILE_TEMPLATE_TYPE) -> ::windows::runtime::HRESULT,
5252     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, ppinned: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5253     #[cfg(not(feature = "Win32_Foundation"))] usize,
5254     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, pposition: *mut u32) -> ::windows::runtime::HRESULT,
5255     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisnotified: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5256     #[cfg(not(feature = "Win32_Foundation"))] usize,
5257     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisdefault: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5258     #[cfg(not(feature = "Win32_Foundation"))] usize,
5259     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ptaskid: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5260     #[cfg(not(feature = "Win32_Foundation"))] usize,
5261     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstarttiletype: *mut PM_STARTTILE_TYPE) -> ::windows::runtime::HRESULT,
5262     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisthemable: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5263     #[cfg(not(feature = "Win32_Foundation"))] usize,
5264     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propid: u32, pppropinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5265     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pimageurn: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pparameters: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5266     #[cfg(not(feature = "Win32_Foundation"))] usize,
5267     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pptilepropenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5268     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, psize: *mut PM_TILE_SIZE) -> ::windows::runtime::HRESULT,
5269     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, position: u32) -> ::windows::runtime::HRESULT,
5270     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, notified: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5271     #[cfg(not(feature = "Win32_Foundation"))] usize,
5272     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, pinned: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5273     #[cfg(not(feature = "Win32_Foundation"))] usize,
5274     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hubtype: PM_TILE_HUBTYPE, size: PM_TILE_SIZE) -> ::windows::runtime::HRESULT,
5275     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, taskname: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, taskparameters: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5276     #[cfg(not(feature = "Win32_Foundation"))] usize,
5277     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pblob: *mut ::std::mem::ManuallyDrop<PM_STARTTILEBLOB>) -> ::windows::runtime::HRESULT,
5278     #[cfg(not(feature = "Win32_Foundation"))] usize,
5279     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisrestoring: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5280     #[cfg(not(feature = "Win32_Foundation"))] usize,
5281     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pisautorestoredisabled: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5282     #[cfg(not(feature = "Win32_Foundation"))] usize,
5283     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, restoring: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5284     #[cfg(not(feature = "Win32_Foundation"))] usize,
5285     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, autorestoredisabled: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
5286     #[cfg(not(feature = "Win32_Foundation"))] usize,
5287 );
5288 #[repr(transparent)]
5289 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5290 pub struct IPMTileInfoEnumerator(::windows::runtime::IUnknown);
5291 impl IPMTileInfoEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMTileInfo>5292     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMTileInfo> {
5293         let mut result__: <IPMTileInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5294         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMTileInfo>(result__)
5295     }
5296 }
5297 unsafe impl ::windows::runtime::Interface for IPMTileInfoEnumerator {
5298     type Vtable = IPMTileInfoEnumerator_abi;
5299     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3738710117, 58466, 19244, [172, 181, 227, 156, 234, 97, 200, 116]);
5300 }
5301 impl ::std::convert::From<IPMTileInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMTileInfoEnumerator) -> Self5302     fn from(value: IPMTileInfoEnumerator) -> Self {
5303         unsafe { ::std::mem::transmute(value) }
5304     }
5305 }
5306 impl ::std::convert::From<&IPMTileInfoEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMTileInfoEnumerator) -> Self5307     fn from(value: &IPMTileInfoEnumerator) -> Self {
5308         ::std::convert::From::from(::std::clone::Clone::clone(value))
5309     }
5310 }
5311 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTileInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5312     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5313         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5314     }
5315 }
5316 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTileInfoEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5317     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5318         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5319     }
5320 }
5321 #[repr(C)]
5322 #[doc(hidden)]
5323 pub struct IPMTileInfoEnumerator_abi(
5324     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5325     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5326     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5327     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pptileinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5328 );
5329 #[repr(transparent)]
5330 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5331 pub struct IPMTilePropertyEnumerator(::windows::runtime::IUnknown);
5332 impl IPMTilePropertyEnumerator {
Next(&self) -> ::windows::runtime::Result<IPMTilePropertyInfo>5333     pub unsafe fn Next(&self) -> ::windows::runtime::Result<IPMTilePropertyInfo> {
5334         let mut result__: <IPMTilePropertyInfo as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5335         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IPMTilePropertyInfo>(result__)
5336     }
5337 }
5338 unsafe impl ::windows::runtime::Interface for IPMTilePropertyEnumerator {
5339     type Vtable = IPMTilePropertyEnumerator_abi;
5340     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3427587625, 36935, 16976, [170, 200, 147, 14, 71, 129, 36, 33]);
5341 }
5342 impl ::std::convert::From<IPMTilePropertyEnumerator> for ::windows::runtime::IUnknown {
from(value: IPMTilePropertyEnumerator) -> Self5343     fn from(value: IPMTilePropertyEnumerator) -> Self {
5344         unsafe { ::std::mem::transmute(value) }
5345     }
5346 }
5347 impl ::std::convert::From<&IPMTilePropertyEnumerator> for ::windows::runtime::IUnknown {
from(value: &IPMTilePropertyEnumerator) -> Self5348     fn from(value: &IPMTilePropertyEnumerator) -> Self {
5349         ::std::convert::From::from(::std::clone::Clone::clone(value))
5350     }
5351 }
5352 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTilePropertyEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5353     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5354         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5355     }
5356 }
5357 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTilePropertyEnumerator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5358     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5359         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5360     }
5361 }
5362 #[repr(C)]
5363 #[doc(hidden)]
5364 pub struct IPMTilePropertyEnumerator_abi(
5365     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5366     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5367     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5368     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pppropinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5369 );
5370 #[repr(transparent)]
5371 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5372 pub struct IPMTilePropertyInfo(::windows::runtime::IUnknown);
5373 impl IPMTilePropertyInfo {
PropertyID(&self) -> ::windows::runtime::Result<u32>5374     pub unsafe fn PropertyID(&self) -> ::windows::runtime::Result<u32> {
5375         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
5376         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
5377     }
5378     #[cfg(feature = "Win32_Foundation")]
PropertyValue(&self, ppropvalue: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()>5379     pub unsafe fn PropertyValue(&self, ppropvalue: *mut super::super::Foundation::BSTR) -> ::windows::runtime::Result<()> {
5380         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(ppropvalue)).ok()
5381     }
5382     #[cfg(feature = "Win32_Foundation")]
set_Property<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, propvalue: Param0) -> ::windows::runtime::Result<()>5383     pub unsafe fn set_Property<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, propvalue: Param0) -> ::windows::runtime::Result<()> {
5384         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), propvalue.into_param().abi()).ok()
5385     }
5386 }
5387 unsafe impl ::windows::runtime::Interface for IPMTilePropertyInfo {
5388     type Vtable = IPMTilePropertyInfo_abi;
5389     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1814790167, 7930, 17063, [134, 192, 109, 75, 100, 11, 245, 40]);
5390 }
5391 impl ::std::convert::From<IPMTilePropertyInfo> for ::windows::runtime::IUnknown {
from(value: IPMTilePropertyInfo) -> Self5392     fn from(value: IPMTilePropertyInfo) -> Self {
5393         unsafe { ::std::mem::transmute(value) }
5394     }
5395 }
5396 impl ::std::convert::From<&IPMTilePropertyInfo> for ::windows::runtime::IUnknown {
from(value: &IPMTilePropertyInfo) -> Self5397     fn from(value: &IPMTilePropertyInfo) -> Self {
5398         ::std::convert::From::from(::std::clone::Clone::clone(value))
5399     }
5400 }
5401 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IPMTilePropertyInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5402     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5403         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5404     }
5405 }
5406 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IPMTilePropertyInfo {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5407     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5408         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5409     }
5410 }
5411 #[repr(C)]
5412 #[doc(hidden)]
5413 pub struct IPMTilePropertyInfo_abi(
5414     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5415     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5416     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5417     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppropid: *mut u32) -> ::windows::runtime::HRESULT,
5418     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppropvalue: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5419     #[cfg(not(feature = "Win32_Foundation"))] usize,
5420     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propvalue: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
5421     #[cfg(not(feature = "Win32_Foundation"))] usize,
5422 );
5423 #[repr(transparent)]
5424 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
5425 pub struct IValidate(::windows::runtime::IUnknown);
5426 impl IValidate {
5427     #[cfg(feature = "Win32_Foundation")]
OpenDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szdatabase: Param0) -> ::windows::runtime::Result<()>5428     pub unsafe fn OpenDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szdatabase: Param0) -> ::windows::runtime::Result<()> {
5429         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), szdatabase.into_param().abi()).ok()
5430     }
5431     #[cfg(feature = "Win32_Foundation")]
OpenCUB<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szcubfile: Param0) -> ::windows::runtime::Result<()>5432     pub unsafe fn OpenCUB<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, szcubfile: Param0) -> ::windows::runtime::Result<()> {
5433         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), szcubfile.into_param().abi()).ok()
5434     }
CloseDatabase(&self) -> ::windows::runtime::Result<()>5435     pub unsafe fn CloseDatabase(&self) -> ::windows::runtime::Result<()> {
5436         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
5437     }
CloseCUB(&self) -> ::windows::runtime::Result<()>5438     pub unsafe fn CloseCUB(&self) -> ::windows::runtime::Result<()> {
5439         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self)).ok()
5440     }
5441     #[cfg(feature = "Win32_Foundation")]
SetDisplay(&self, pdisplayfunction: ::std::option::Option<LPDISPLAYVAL>, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>5442     pub unsafe fn SetDisplay(&self, pdisplayfunction: ::std::option::Option<LPDISPLAYVAL>, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5443         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdisplayfunction), ::std::mem::transmute(pcontext)).ok()
5444     }
5445     #[cfg(feature = "Win32_Foundation")]
SetStatus(&self, pstatusfunction: ::std::option::Option<LPEVALCOMCALLBACK>, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>5446     pub unsafe fn SetStatus(&self, pstatusfunction: ::std::option::Option<LPEVALCOMCALLBACK>, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5447         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(pstatusfunction), ::std::mem::transmute(pcontext)).ok()
5448     }
5449     #[cfg(feature = "Win32_Foundation")]
Validate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, wzices: Param0) -> ::windows::runtime::Result<()>5450     pub unsafe fn Validate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, wzices: Param0) -> ::windows::runtime::Result<()> {
5451         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), wzices.into_param().abi()).ok()
5452     }
5453 }
5454 unsafe impl ::windows::runtime::Interface for IValidate {
5455     type Vtable = IValidate_abi;
5456     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3833783750, 58142, 16707, [162, 230, 219, 195, 216, 228, 184, 211]);
5457 }
5458 impl ::std::convert::From<IValidate> for ::windows::runtime::IUnknown {
from(value: IValidate) -> Self5459     fn from(value: IValidate) -> Self {
5460         unsafe { ::std::mem::transmute(value) }
5461     }
5462 }
5463 impl ::std::convert::From<&IValidate> for ::windows::runtime::IUnknown {
from(value: &IValidate) -> Self5464     fn from(value: &IValidate) -> Self {
5465         ::std::convert::From::from(::std::clone::Clone::clone(value))
5466     }
5467 }
5468 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IValidate {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5469     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5470         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
5471     }
5472 }
5473 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IValidate {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>5474     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
5475         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
5476     }
5477 }
5478 #[repr(C)]
5479 #[doc(hidden)]
5480 pub struct IValidate_abi(
5481     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5482     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5483     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
5484     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, szdatabase: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
5485     #[cfg(not(feature = "Win32_Foundation"))] usize,
5486     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, szcubfile: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
5487     #[cfg(not(feature = "Win32_Foundation"))] usize,
5488     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5489     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
5490     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdisplayfunction: ::windows::runtime::RawPtr, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
5491     #[cfg(not(feature = "Win32_Foundation"))] usize,
5492     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pstatusfunction: ::windows::runtime::RawPtr, pcontext: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
5493     #[cfg(not(feature = "Win32_Foundation"))] usize,
5494     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, wzices: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
5495     #[cfg(not(feature = "Win32_Foundation"))] usize,
5496 );
5497 pub const LIBID_MsmMergeTypeLib: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298671, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
5498 pub const LOGALL: u32 = 15u32;
5499 pub const LOGERR: u32 = 4u32;
5500 pub const LOGINFO: u32 = 1u32;
5501 pub const LOGNONE: u32 = 0u32;
5502 pub const LOGPERFMESSAGES: u32 = 8u32;
5503 pub const LOGTOKEN_NO_LOG: u32 = 1u32;
5504 pub const LOGTOKEN_SETUPAPI_APPLOG: u32 = 2u32;
5505 pub const LOGTOKEN_SETUPAPI_DEVLOG: u32 = 3u32;
5506 pub const LOGTOKEN_TYPE_MASK: u32 = 3u32;
5507 pub const LOGTOKEN_UNSPECIFIED: u32 = 0u32;
5508 pub const LOGWARN: u32 = 2u32;
5509 #[cfg(feature = "Win32_Foundation")]
5510 pub type LPDISPLAYVAL = unsafe extern "system" fn(pcontext: *mut ::std::ffi::c_void, uitype: RESULTTYPES, szwval: super::super::Foundation::PWSTR, szwdescription: super::super::Foundation::PWSTR, szwlocation: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
5511 #[cfg(feature = "Win32_Foundation")]
5512 pub type LPEVALCOMCALLBACK = unsafe extern "system" fn(istatus: STATUSTYPES, szdata: super::super::Foundation::PWSTR, pcontext: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
5513 pub const MAX_FEATURE_CHARS: u32 = 38u32;
5514 pub const MAX_GUID_CHARS: u32 = 38u32;
5515 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5516 #[repr(transparent)]
5517 pub struct MSIADVERTISEOPTIONFLAGS(pub i32);
5518 pub const MSIADVERTISEOPTIONFLAGS_INSTANCE: MSIADVERTISEOPTIONFLAGS = MSIADVERTISEOPTIONFLAGS(1i32);
5519 impl ::std::convert::From<i32> for MSIADVERTISEOPTIONFLAGS {
from(value: i32) -> Self5520     fn from(value: i32) -> Self {
5521         Self(value)
5522     }
5523 }
5524 unsafe impl ::windows::runtime::Abi for MSIADVERTISEOPTIONFLAGS {
5525     type Abi = Self;
5526     type DefaultType = Self;
5527 }
5528 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5529 #[repr(transparent)]
5530 pub struct MSIARCHITECTUREFLAGS(pub i32);
5531 pub const MSIARCHITECTUREFLAGS_X86: MSIARCHITECTUREFLAGS = MSIARCHITECTUREFLAGS(1i32);
5532 pub const MSIARCHITECTUREFLAGS_IA64: MSIARCHITECTUREFLAGS = MSIARCHITECTUREFLAGS(2i32);
5533 pub const MSIARCHITECTUREFLAGS_AMD64: MSIARCHITECTUREFLAGS = MSIARCHITECTUREFLAGS(4i32);
5534 pub const MSIARCHITECTUREFLAGS_ARM: MSIARCHITECTUREFLAGS = MSIARCHITECTUREFLAGS(8i32);
5535 impl ::std::convert::From<i32> for MSIARCHITECTUREFLAGS {
from(value: i32) -> Self5536     fn from(value: i32) -> Self {
5537         Self(value)
5538     }
5539 }
5540 unsafe impl ::windows::runtime::Abi for MSIARCHITECTUREFLAGS {
5541     type Abi = Self;
5542     type DefaultType = Self;
5543 }
5544 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5545 #[repr(transparent)]
5546 pub struct MSIASSEMBLYINFO(pub u32);
5547 pub const MSIASSEMBLYINFO_NETASSEMBLY: MSIASSEMBLYINFO = MSIASSEMBLYINFO(0u32);
5548 pub const MSIASSEMBLYINFO_WIN32ASSEMBLY: MSIASSEMBLYINFO = MSIASSEMBLYINFO(1u32);
5549 impl ::std::convert::From<u32> for MSIASSEMBLYINFO {
from(value: u32) -> Self5550     fn from(value: u32) -> Self {
5551         Self(value)
5552     }
5553 }
5554 unsafe impl ::windows::runtime::Abi for MSIASSEMBLYINFO {
5555     type Abi = Self;
5556     type DefaultType = Self;
5557 }
5558 impl ::std::ops::BitOr for MSIASSEMBLYINFO {
5559     type Output = Self;
bitor(self, rhs: Self) -> Self5560     fn bitor(self, rhs: Self) -> Self {
5561         Self(self.0 | rhs.0)
5562     }
5563 }
5564 impl ::std::ops::BitAnd for MSIASSEMBLYINFO {
5565     type Output = Self;
bitand(self, rhs: Self) -> Self5566     fn bitand(self, rhs: Self) -> Self {
5567         Self(self.0 & rhs.0)
5568     }
5569 }
5570 impl ::std::ops::BitOrAssign for MSIASSEMBLYINFO {
bitor_assign(&mut self, rhs: Self)5571     fn bitor_assign(&mut self, rhs: Self) {
5572         self.0.bitor_assign(rhs.0)
5573     }
5574 }
5575 impl ::std::ops::BitAndAssign for MSIASSEMBLYINFO {
bitand_assign(&mut self, rhs: Self)5576     fn bitand_assign(&mut self, rhs: Self) {
5577         self.0.bitand_assign(rhs.0)
5578     }
5579 }
5580 impl ::std::ops::Not for MSIASSEMBLYINFO {
5581     type Output = Self;
not(self) -> Self5582     fn not(self) -> Self {
5583         Self(self.0.not())
5584     }
5585 }
5586 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5587 #[repr(transparent)]
5588 pub struct MSICODE(pub i32);
5589 pub const MSICODE_PRODUCT: MSICODE = MSICODE(0i32);
5590 pub const MSICODE_PATCH: MSICODE = MSICODE(1073741824i32);
5591 impl ::std::convert::From<i32> for MSICODE {
from(value: i32) -> Self5592     fn from(value: i32) -> Self {
5593         Self(value)
5594     }
5595 }
5596 unsafe impl ::windows::runtime::Abi for MSICODE {
5597     type Abi = Self;
5598     type DefaultType = Self;
5599 }
5600 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5601 #[repr(transparent)]
5602 pub struct MSICOLINFO(pub i32);
5603 pub const MSICOLINFO_NAMES: MSICOLINFO = MSICOLINFO(0i32);
5604 pub const MSICOLINFO_TYPES: MSICOLINFO = MSICOLINFO(1i32);
5605 impl ::std::convert::From<i32> for MSICOLINFO {
from(value: i32) -> Self5606     fn from(value: i32) -> Self {
5607         Self(value)
5608     }
5609 }
5610 unsafe impl ::windows::runtime::Abi for MSICOLINFO {
5611     type Abi = Self;
5612     type DefaultType = Self;
5613 }
5614 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5615 #[repr(transparent)]
5616 pub struct MSICONDITION(pub i32);
5617 pub const MSICONDITION_FALSE: MSICONDITION = MSICONDITION(0i32);
5618 pub const MSICONDITION_TRUE: MSICONDITION = MSICONDITION(1i32);
5619 pub const MSICONDITION_NONE: MSICONDITION = MSICONDITION(2i32);
5620 pub const MSICONDITION_ERROR: MSICONDITION = MSICONDITION(3i32);
5621 impl ::std::convert::From<i32> for MSICONDITION {
from(value: i32) -> Self5622     fn from(value: i32) -> Self {
5623         Self(value)
5624     }
5625 }
5626 unsafe impl ::windows::runtime::Abi for MSICONDITION {
5627     type Abi = Self;
5628     type DefaultType = Self;
5629 }
5630 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5631 #[repr(transparent)]
5632 pub struct MSICOSTTREE(pub i32);
5633 pub const MSICOSTTREE_SELFONLY: MSICOSTTREE = MSICOSTTREE(0i32);
5634 pub const MSICOSTTREE_CHILDREN: MSICOSTTREE = MSICOSTTREE(1i32);
5635 pub const MSICOSTTREE_PARENTS: MSICOSTTREE = MSICOSTTREE(2i32);
5636 pub const MSICOSTTREE_RESERVED: MSICOSTTREE = MSICOSTTREE(3i32);
5637 impl ::std::convert::From<i32> for MSICOSTTREE {
from(value: i32) -> Self5638     fn from(value: i32) -> Self {
5639         Self(value)
5640     }
5641 }
5642 unsafe impl ::windows::runtime::Abi for MSICOSTTREE {
5643     type Abi = Self;
5644     type DefaultType = Self;
5645 }
5646 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5647 #[repr(transparent)]
5648 pub struct MSIDBERROR(pub i32);
5649 pub const MSIDBERROR_INVALIDARG: MSIDBERROR = MSIDBERROR(-3i32);
5650 pub const MSIDBERROR_MOREDATA: MSIDBERROR = MSIDBERROR(-2i32);
5651 pub const MSIDBERROR_FUNCTIONERROR: MSIDBERROR = MSIDBERROR(-1i32);
5652 pub const MSIDBERROR_NOERROR: MSIDBERROR = MSIDBERROR(0i32);
5653 pub const MSIDBERROR_DUPLICATEKEY: MSIDBERROR = MSIDBERROR(1i32);
5654 pub const MSIDBERROR_REQUIRED: MSIDBERROR = MSIDBERROR(2i32);
5655 pub const MSIDBERROR_BADLINK: MSIDBERROR = MSIDBERROR(3i32);
5656 pub const MSIDBERROR_OVERFLOW: MSIDBERROR = MSIDBERROR(4i32);
5657 pub const MSIDBERROR_UNDERFLOW: MSIDBERROR = MSIDBERROR(5i32);
5658 pub const MSIDBERROR_NOTINSET: MSIDBERROR = MSIDBERROR(6i32);
5659 pub const MSIDBERROR_BADVERSION: MSIDBERROR = MSIDBERROR(7i32);
5660 pub const MSIDBERROR_BADCASE: MSIDBERROR = MSIDBERROR(8i32);
5661 pub const MSIDBERROR_BADGUID: MSIDBERROR = MSIDBERROR(9i32);
5662 pub const MSIDBERROR_BADWILDCARD: MSIDBERROR = MSIDBERROR(10i32);
5663 pub const MSIDBERROR_BADIDENTIFIER: MSIDBERROR = MSIDBERROR(11i32);
5664 pub const MSIDBERROR_BADLANGUAGE: MSIDBERROR = MSIDBERROR(12i32);
5665 pub const MSIDBERROR_BADFILENAME: MSIDBERROR = MSIDBERROR(13i32);
5666 pub const MSIDBERROR_BADPATH: MSIDBERROR = MSIDBERROR(14i32);
5667 pub const MSIDBERROR_BADCONDITION: MSIDBERROR = MSIDBERROR(15i32);
5668 pub const MSIDBERROR_BADFORMATTED: MSIDBERROR = MSIDBERROR(16i32);
5669 pub const MSIDBERROR_BADTEMPLATE: MSIDBERROR = MSIDBERROR(17i32);
5670 pub const MSIDBERROR_BADDEFAULTDIR: MSIDBERROR = MSIDBERROR(18i32);
5671 pub const MSIDBERROR_BADREGPATH: MSIDBERROR = MSIDBERROR(19i32);
5672 pub const MSIDBERROR_BADCUSTOMSOURCE: MSIDBERROR = MSIDBERROR(20i32);
5673 pub const MSIDBERROR_BADPROPERTY: MSIDBERROR = MSIDBERROR(21i32);
5674 pub const MSIDBERROR_MISSINGDATA: MSIDBERROR = MSIDBERROR(22i32);
5675 pub const MSIDBERROR_BADCATEGORY: MSIDBERROR = MSIDBERROR(23i32);
5676 pub const MSIDBERROR_BADKEYTABLE: MSIDBERROR = MSIDBERROR(24i32);
5677 pub const MSIDBERROR_BADMAXMINVALUES: MSIDBERROR = MSIDBERROR(25i32);
5678 pub const MSIDBERROR_BADCABINET: MSIDBERROR = MSIDBERROR(26i32);
5679 pub const MSIDBERROR_BADSHORTCUT: MSIDBERROR = MSIDBERROR(27i32);
5680 pub const MSIDBERROR_STRINGOVERFLOW: MSIDBERROR = MSIDBERROR(28i32);
5681 pub const MSIDBERROR_BADLOCALIZEATTRIB: MSIDBERROR = MSIDBERROR(29i32);
5682 impl ::std::convert::From<i32> for MSIDBERROR {
from(value: i32) -> Self5683     fn from(value: i32) -> Self {
5684         Self(value)
5685     }
5686 }
5687 unsafe impl ::windows::runtime::Abi for MSIDBERROR {
5688     type Abi = Self;
5689     type DefaultType = Self;
5690 }
5691 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5692 #[repr(transparent)]
5693 pub struct MSIDBSTATE(pub i32);
5694 pub const MSIDBSTATE_ERROR: MSIDBSTATE = MSIDBSTATE(-1i32);
5695 pub const MSIDBSTATE_READ: MSIDBSTATE = MSIDBSTATE(0i32);
5696 pub const MSIDBSTATE_WRITE: MSIDBSTATE = MSIDBSTATE(1i32);
5697 impl ::std::convert::From<i32> for MSIDBSTATE {
from(value: i32) -> Self5698     fn from(value: i32) -> Self {
5699         Self(value)
5700     }
5701 }
5702 unsafe impl ::windows::runtime::Abi for MSIDBSTATE {
5703     type Abi = Self;
5704     type DefaultType = Self;
5705 }
5706 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5707 #[repr(C)]
5708 pub struct MSIFILEHASHINFO {
5709     pub dwFileHashInfoSize: u32,
5710     pub dwData: [u32; 4],
5711 }
5712 impl MSIFILEHASHINFO {}
5713 impl ::std::default::Default for MSIFILEHASHINFO {
default() -> Self5714     fn default() -> Self {
5715         unsafe { ::std::mem::zeroed() }
5716     }
5717 }
5718 impl ::std::fmt::Debug for MSIFILEHASHINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5719     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5720         fmt.debug_struct("MSIFILEHASHINFO").field("dwFileHashInfoSize", &self.dwFileHashInfoSize).field("dwData", &self.dwData).finish()
5721     }
5722 }
5723 impl ::std::cmp::PartialEq for MSIFILEHASHINFO {
eq(&self, other: &Self) -> bool5724     fn eq(&self, other: &Self) -> bool {
5725         self.dwFileHashInfoSize == other.dwFileHashInfoSize && self.dwData == other.dwData
5726     }
5727 }
5728 impl ::std::cmp::Eq for MSIFILEHASHINFO {}
5729 unsafe impl ::windows::runtime::Abi for MSIFILEHASHINFO {
5730     type Abi = Self;
5731     type DefaultType = Self;
5732 }
5733 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
5734 #[repr(transparent)]
5735 pub struct MSIHANDLE(pub u32);
5736 impl ::std::default::Default for MSIHANDLE {
default() -> Self5737     fn default() -> Self {
5738         unsafe { ::std::mem::zeroed() }
5739     }
5740 }
5741 unsafe impl ::windows::runtime::Handle for MSIHANDLE {}
5742 unsafe impl ::windows::runtime::Abi for MSIHANDLE {
5743     type Abi = Self;
5744     type DefaultType = Self;
5745 }
5746 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5747 #[repr(transparent)]
5748 pub struct MSIINSTALLCONTEXT(pub i32);
5749 pub const MSIINSTALLCONTEXT_FIRSTVISIBLE: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(0i32);
5750 pub const MSIINSTALLCONTEXT_NONE: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(0i32);
5751 pub const MSIINSTALLCONTEXT_USERMANAGED: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(1i32);
5752 pub const MSIINSTALLCONTEXT_USERUNMANAGED: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(2i32);
5753 pub const MSIINSTALLCONTEXT_MACHINE: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(4i32);
5754 pub const MSIINSTALLCONTEXT_ALL: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(7i32);
5755 pub const MSIINSTALLCONTEXT_ALLUSERMANAGED: MSIINSTALLCONTEXT = MSIINSTALLCONTEXT(8i32);
5756 impl ::std::convert::From<i32> for MSIINSTALLCONTEXT {
from(value: i32) -> Self5757     fn from(value: i32) -> Self {
5758         Self(value)
5759     }
5760 }
5761 unsafe impl ::windows::runtime::Abi for MSIINSTALLCONTEXT {
5762     type Abi = Self;
5763     type DefaultType = Self;
5764 }
5765 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5766 #[repr(transparent)]
5767 pub struct MSIMODIFY(pub i32);
5768 pub const MSIMODIFY_SEEK: MSIMODIFY = MSIMODIFY(-1i32);
5769 pub const MSIMODIFY_REFRESH: MSIMODIFY = MSIMODIFY(0i32);
5770 pub const MSIMODIFY_INSERT: MSIMODIFY = MSIMODIFY(1i32);
5771 pub const MSIMODIFY_UPDATE: MSIMODIFY = MSIMODIFY(2i32);
5772 pub const MSIMODIFY_ASSIGN: MSIMODIFY = MSIMODIFY(3i32);
5773 pub const MSIMODIFY_REPLACE: MSIMODIFY = MSIMODIFY(4i32);
5774 pub const MSIMODIFY_MERGE: MSIMODIFY = MSIMODIFY(5i32);
5775 pub const MSIMODIFY_DELETE: MSIMODIFY = MSIMODIFY(6i32);
5776 pub const MSIMODIFY_INSERT_TEMPORARY: MSIMODIFY = MSIMODIFY(7i32);
5777 pub const MSIMODIFY_VALIDATE: MSIMODIFY = MSIMODIFY(8i32);
5778 pub const MSIMODIFY_VALIDATE_NEW: MSIMODIFY = MSIMODIFY(9i32);
5779 pub const MSIMODIFY_VALIDATE_FIELD: MSIMODIFY = MSIMODIFY(10i32);
5780 pub const MSIMODIFY_VALIDATE_DELETE: MSIMODIFY = MSIMODIFY(11i32);
5781 impl ::std::convert::From<i32> for MSIMODIFY {
from(value: i32) -> Self5782     fn from(value: i32) -> Self {
5783         Self(value)
5784     }
5785 }
5786 unsafe impl ::windows::runtime::Abi for MSIMODIFY {
5787     type Abi = Self;
5788     type DefaultType = Self;
5789 }
5790 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5791 #[repr(transparent)]
5792 pub struct MSIOPENPACKAGEFLAGS(pub i32);
5793 pub const MSIOPENPACKAGEFLAGS_IGNOREMACHINESTATE: MSIOPENPACKAGEFLAGS = MSIOPENPACKAGEFLAGS(1i32);
5794 impl ::std::convert::From<i32> for MSIOPENPACKAGEFLAGS {
from(value: i32) -> Self5795     fn from(value: i32) -> Self {
5796         Self(value)
5797     }
5798 }
5799 unsafe impl ::windows::runtime::Abi for MSIOPENPACKAGEFLAGS {
5800     type Abi = Self;
5801     type DefaultType = Self;
5802 }
5803 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5804 #[repr(transparent)]
5805 pub struct MSIPATCHDATATYPE(pub i32);
5806 pub const MSIPATCH_DATATYPE_PATCHFILE: MSIPATCHDATATYPE = MSIPATCHDATATYPE(0i32);
5807 pub const MSIPATCH_DATATYPE_XMLPATH: MSIPATCHDATATYPE = MSIPATCHDATATYPE(1i32);
5808 pub const MSIPATCH_DATATYPE_XMLBLOB: MSIPATCHDATATYPE = MSIPATCHDATATYPE(2i32);
5809 impl ::std::convert::From<i32> for MSIPATCHDATATYPE {
from(value: i32) -> Self5810     fn from(value: i32) -> Self {
5811         Self(value)
5812     }
5813 }
5814 unsafe impl ::windows::runtime::Abi for MSIPATCHDATATYPE {
5815     type Abi = Self;
5816     type DefaultType = Self;
5817 }
5818 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5819 #[repr(C)]
5820 #[cfg(feature = "Win32_Foundation")]
5821 pub struct MSIPATCHSEQUENCEINFOA {
5822     pub szPatchData: super::super::Foundation::PSTR,
5823     pub ePatchDataType: MSIPATCHDATATYPE,
5824     pub dwOrder: u32,
5825     pub uStatus: u32,
5826 }
5827 #[cfg(feature = "Win32_Foundation")]
5828 impl MSIPATCHSEQUENCEINFOA {}
5829 #[cfg(feature = "Win32_Foundation")]
5830 impl ::std::default::Default for MSIPATCHSEQUENCEINFOA {
default() -> Self5831     fn default() -> Self {
5832         unsafe { ::std::mem::zeroed() }
5833     }
5834 }
5835 #[cfg(feature = "Win32_Foundation")]
5836 impl ::std::fmt::Debug for MSIPATCHSEQUENCEINFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5837     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5838         fmt.debug_struct("MSIPATCHSEQUENCEINFOA").field("szPatchData", &self.szPatchData).field("ePatchDataType", &self.ePatchDataType).field("dwOrder", &self.dwOrder).field("uStatus", &self.uStatus).finish()
5839     }
5840 }
5841 #[cfg(feature = "Win32_Foundation")]
5842 impl ::std::cmp::PartialEq for MSIPATCHSEQUENCEINFOA {
eq(&self, other: &Self) -> bool5843     fn eq(&self, other: &Self) -> bool {
5844         self.szPatchData == other.szPatchData && self.ePatchDataType == other.ePatchDataType && self.dwOrder == other.dwOrder && self.uStatus == other.uStatus
5845     }
5846 }
5847 #[cfg(feature = "Win32_Foundation")]
5848 impl ::std::cmp::Eq for MSIPATCHSEQUENCEINFOA {}
5849 #[cfg(feature = "Win32_Foundation")]
5850 unsafe impl ::windows::runtime::Abi for MSIPATCHSEQUENCEINFOA {
5851     type Abi = Self;
5852     type DefaultType = Self;
5853 }
5854 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5855 #[repr(C)]
5856 #[cfg(feature = "Win32_Foundation")]
5857 pub struct MSIPATCHSEQUENCEINFOW {
5858     pub szPatchData: super::super::Foundation::PWSTR,
5859     pub ePatchDataType: MSIPATCHDATATYPE,
5860     pub dwOrder: u32,
5861     pub uStatus: u32,
5862 }
5863 #[cfg(feature = "Win32_Foundation")]
5864 impl MSIPATCHSEQUENCEINFOW {}
5865 #[cfg(feature = "Win32_Foundation")]
5866 impl ::std::default::Default for MSIPATCHSEQUENCEINFOW {
default() -> Self5867     fn default() -> Self {
5868         unsafe { ::std::mem::zeroed() }
5869     }
5870 }
5871 #[cfg(feature = "Win32_Foundation")]
5872 impl ::std::fmt::Debug for MSIPATCHSEQUENCEINFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5873     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5874         fmt.debug_struct("MSIPATCHSEQUENCEINFOW").field("szPatchData", &self.szPatchData).field("ePatchDataType", &self.ePatchDataType).field("dwOrder", &self.dwOrder).field("uStatus", &self.uStatus).finish()
5875     }
5876 }
5877 #[cfg(feature = "Win32_Foundation")]
5878 impl ::std::cmp::PartialEq for MSIPATCHSEQUENCEINFOW {
eq(&self, other: &Self) -> bool5879     fn eq(&self, other: &Self) -> bool {
5880         self.szPatchData == other.szPatchData && self.ePatchDataType == other.ePatchDataType && self.dwOrder == other.dwOrder && self.uStatus == other.uStatus
5881     }
5882 }
5883 #[cfg(feature = "Win32_Foundation")]
5884 impl ::std::cmp::Eq for MSIPATCHSEQUENCEINFOW {}
5885 #[cfg(feature = "Win32_Foundation")]
5886 unsafe impl ::windows::runtime::Abi for MSIPATCHSEQUENCEINFOW {
5887     type Abi = Self;
5888     type DefaultType = Self;
5889 }
5890 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5891 #[repr(transparent)]
5892 pub struct MSIPATCHSTATE(pub i32);
5893 pub const MSIPATCHSTATE_INVALID: MSIPATCHSTATE = MSIPATCHSTATE(0i32);
5894 pub const MSIPATCHSTATE_APPLIED: MSIPATCHSTATE = MSIPATCHSTATE(1i32);
5895 pub const MSIPATCHSTATE_SUPERSEDED: MSIPATCHSTATE = MSIPATCHSTATE(2i32);
5896 pub const MSIPATCHSTATE_OBSOLETED: MSIPATCHSTATE = MSIPATCHSTATE(4i32);
5897 pub const MSIPATCHSTATE_REGISTERED: MSIPATCHSTATE = MSIPATCHSTATE(8i32);
5898 pub const MSIPATCHSTATE_ALL: MSIPATCHSTATE = MSIPATCHSTATE(15i32);
5899 impl ::std::convert::From<i32> for MSIPATCHSTATE {
from(value: i32) -> Self5900     fn from(value: i32) -> Self {
5901         Self(value)
5902     }
5903 }
5904 unsafe impl ::windows::runtime::Abi for MSIPATCHSTATE {
5905     type Abi = Self;
5906     type DefaultType = Self;
5907 }
5908 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5909 #[repr(transparent)]
5910 pub struct MSIRUNMODE(pub i32);
5911 pub const MSIRUNMODE_ADMIN: MSIRUNMODE = MSIRUNMODE(0i32);
5912 pub const MSIRUNMODE_ADVERTISE: MSIRUNMODE = MSIRUNMODE(1i32);
5913 pub const MSIRUNMODE_MAINTENANCE: MSIRUNMODE = MSIRUNMODE(2i32);
5914 pub const MSIRUNMODE_ROLLBACKENABLED: MSIRUNMODE = MSIRUNMODE(3i32);
5915 pub const MSIRUNMODE_LOGENABLED: MSIRUNMODE = MSIRUNMODE(4i32);
5916 pub const MSIRUNMODE_OPERATIONS: MSIRUNMODE = MSIRUNMODE(5i32);
5917 pub const MSIRUNMODE_REBOOTATEND: MSIRUNMODE = MSIRUNMODE(6i32);
5918 pub const MSIRUNMODE_REBOOTNOW: MSIRUNMODE = MSIRUNMODE(7i32);
5919 pub const MSIRUNMODE_CABINET: MSIRUNMODE = MSIRUNMODE(8i32);
5920 pub const MSIRUNMODE_SOURCESHORTNAMES: MSIRUNMODE = MSIRUNMODE(9i32);
5921 pub const MSIRUNMODE_TARGETSHORTNAMES: MSIRUNMODE = MSIRUNMODE(10i32);
5922 pub const MSIRUNMODE_RESERVED11: MSIRUNMODE = MSIRUNMODE(11i32);
5923 pub const MSIRUNMODE_WINDOWS9X: MSIRUNMODE = MSIRUNMODE(12i32);
5924 pub const MSIRUNMODE_ZAWENABLED: MSIRUNMODE = MSIRUNMODE(13i32);
5925 pub const MSIRUNMODE_RESERVED14: MSIRUNMODE = MSIRUNMODE(14i32);
5926 pub const MSIRUNMODE_RESERVED15: MSIRUNMODE = MSIRUNMODE(15i32);
5927 pub const MSIRUNMODE_SCHEDULED: MSIRUNMODE = MSIRUNMODE(16i32);
5928 pub const MSIRUNMODE_ROLLBACK: MSIRUNMODE = MSIRUNMODE(17i32);
5929 pub const MSIRUNMODE_COMMIT: MSIRUNMODE = MSIRUNMODE(18i32);
5930 impl ::std::convert::From<i32> for MSIRUNMODE {
from(value: i32) -> Self5931     fn from(value: i32) -> Self {
5932         Self(value)
5933     }
5934 }
5935 unsafe impl ::windows::runtime::Abi for MSIRUNMODE {
5936     type Abi = Self;
5937     type DefaultType = Self;
5938 }
5939 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5940 #[repr(transparent)]
5941 pub struct MSISOURCETYPE(pub i32);
5942 pub const MSISOURCETYPE_UNKNOWN: MSISOURCETYPE = MSISOURCETYPE(0i32);
5943 pub const MSISOURCETYPE_NETWORK: MSISOURCETYPE = MSISOURCETYPE(1i32);
5944 pub const MSISOURCETYPE_URL: MSISOURCETYPE = MSISOURCETYPE(2i32);
5945 pub const MSISOURCETYPE_MEDIA: MSISOURCETYPE = MSISOURCETYPE(4i32);
5946 impl ::std::convert::From<i32> for MSISOURCETYPE {
from(value: i32) -> Self5947     fn from(value: i32) -> Self {
5948         Self(value)
5949     }
5950 }
5951 unsafe impl ::windows::runtime::Abi for MSISOURCETYPE {
5952     type Abi = Self;
5953     type DefaultType = Self;
5954 }
5955 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5956 #[repr(transparent)]
5957 pub struct MSITRANSACTION(pub i32);
5958 pub const MSITRANSACTION_CHAIN_EMBEDDEDUI: MSITRANSACTION = MSITRANSACTION(1i32);
5959 pub const MSITRANSACTION_JOIN_EXISTING_EMBEDDEDUI: MSITRANSACTION = MSITRANSACTION(2i32);
5960 impl ::std::convert::From<i32> for MSITRANSACTION {
from(value: i32) -> Self5961     fn from(value: i32) -> Self {
5962         Self(value)
5963     }
5964 }
5965 unsafe impl ::windows::runtime::Abi for MSITRANSACTION {
5966     type Abi = Self;
5967     type DefaultType = Self;
5968 }
5969 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5970 #[repr(transparent)]
5971 pub struct MSITRANSACTIONSTATE(pub u32);
5972 pub const MSITRANSACTIONSTATE_ROLLBACK: MSITRANSACTIONSTATE = MSITRANSACTIONSTATE(0u32);
5973 pub const MSITRANSACTIONSTATE_COMMIT: MSITRANSACTIONSTATE = MSITRANSACTIONSTATE(1u32);
5974 impl ::std::convert::From<u32> for MSITRANSACTIONSTATE {
from(value: u32) -> Self5975     fn from(value: u32) -> Self {
5976         Self(value)
5977     }
5978 }
5979 unsafe impl ::windows::runtime::Abi for MSITRANSACTIONSTATE {
5980     type Abi = Self;
5981     type DefaultType = Self;
5982 }
5983 impl ::std::ops::BitOr for MSITRANSACTIONSTATE {
5984     type Output = Self;
bitor(self, rhs: Self) -> Self5985     fn bitor(self, rhs: Self) -> Self {
5986         Self(self.0 | rhs.0)
5987     }
5988 }
5989 impl ::std::ops::BitAnd for MSITRANSACTIONSTATE {
5990     type Output = Self;
bitand(self, rhs: Self) -> Self5991     fn bitand(self, rhs: Self) -> Self {
5992         Self(self.0 & rhs.0)
5993     }
5994 }
5995 impl ::std::ops::BitOrAssign for MSITRANSACTIONSTATE {
bitor_assign(&mut self, rhs: Self)5996     fn bitor_assign(&mut self, rhs: Self) {
5997         self.0.bitor_assign(rhs.0)
5998     }
5999 }
6000 impl ::std::ops::BitAndAssign for MSITRANSACTIONSTATE {
bitand_assign(&mut self, rhs: Self)6001     fn bitand_assign(&mut self, rhs: Self) {
6002         self.0.bitand_assign(rhs.0)
6003     }
6004 }
6005 impl ::std::ops::Not for MSITRANSACTIONSTATE {
6006     type Output = Self;
not(self) -> Self6007     fn not(self) -> Self {
6008         Self(self.0.not())
6009     }
6010 }
6011 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6012 #[repr(transparent)]
6013 pub struct MSITRANSFORM_ERROR(pub i32);
6014 pub const MSITRANSFORM_ERROR_ADDEXISTINGROW: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(1i32);
6015 pub const MSITRANSFORM_ERROR_DELMISSINGROW: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(2i32);
6016 pub const MSITRANSFORM_ERROR_ADDEXISTINGTABLE: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(4i32);
6017 pub const MSITRANSFORM_ERROR_DELMISSINGTABLE: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(8i32);
6018 pub const MSITRANSFORM_ERROR_UPDATEMISSINGROW: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(16i32);
6019 pub const MSITRANSFORM_ERROR_CHANGECODEPAGE: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(32i32);
6020 pub const MSITRANSFORM_ERROR_VIEWTRANSFORM: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(256i32);
6021 pub const MSITRANSFORM_ERROR_NONE: MSITRANSFORM_ERROR = MSITRANSFORM_ERROR(0i32);
6022 impl ::std::convert::From<i32> for MSITRANSFORM_ERROR {
from(value: i32) -> Self6023     fn from(value: i32) -> Self {
6024         Self(value)
6025     }
6026 }
6027 unsafe impl ::windows::runtime::Abi for MSITRANSFORM_ERROR {
6028     type Abi = Self;
6029     type DefaultType = Self;
6030 }
6031 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6032 #[repr(transparent)]
6033 pub struct MSITRANSFORM_VALIDATE(pub i32);
6034 pub const MSITRANSFORM_VALIDATE_LANGUAGE: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(1i32);
6035 pub const MSITRANSFORM_VALIDATE_PRODUCT: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(2i32);
6036 pub const MSITRANSFORM_VALIDATE_PLATFORM: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(4i32);
6037 pub const MSITRANSFORM_VALIDATE_MAJORVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(8i32);
6038 pub const MSITRANSFORM_VALIDATE_MINORVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(16i32);
6039 pub const MSITRANSFORM_VALIDATE_UPDATEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(32i32);
6040 pub const MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(64i32);
6041 pub const MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(128i32);
6042 pub const MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(256i32);
6043 pub const MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(512i32);
6044 pub const MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(1024i32);
6045 pub const MSITRANSFORM_VALIDATE_UPGRADECODE: MSITRANSFORM_VALIDATE = MSITRANSFORM_VALIDATE(2048i32);
6046 impl ::std::convert::From<i32> for MSITRANSFORM_VALIDATE {
from(value: i32) -> Self6047     fn from(value: i32) -> Self {
6048         Self(value)
6049     }
6050 }
6051 unsafe impl ::windows::runtime::Abi for MSITRANSFORM_VALIDATE {
6052     type Abi = Self;
6053     type DefaultType = Self;
6054 }
6055 pub const MSI_INVALID_HASH_IS_FATAL: u32 = 1u32;
6056 pub const MSI_NULL_INTEGER: u32 = 2147483648u32;
6057 #[cfg(feature = "Win32_Foundation")]
6058 #[inline]
MsiAdvertiseProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16) -> u326059 pub unsafe fn MsiAdvertiseProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16) -> u32 {
6060     #[cfg(windows)]
6061     {
6062         #[link(name = "windows")]
6063         extern "system" {
6064             fn MsiAdvertiseProductA(szpackagepath: super::super::Foundation::PSTR, szscriptfilepath: super::super::Foundation::PSTR, sztransforms: super::super::Foundation::PSTR, lgidlanguage: u16) -> u32;
6065         }
6066         ::std::mem::transmute(MsiAdvertiseProductA(szpackagepath.into_param().abi(), szscriptfilepath.into_param().abi(), sztransforms.into_param().abi(), ::std::mem::transmute(lgidlanguage)))
6067     }
6068     #[cfg(not(windows))]
6069     unimplemented!("Unsupported target OS");
6070 }
6071 #[cfg(feature = "Win32_Foundation")]
6072 #[inline]
MsiAdvertiseProductExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u326073 pub unsafe fn MsiAdvertiseProductExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u32 {
6074     #[cfg(windows)]
6075     {
6076         #[link(name = "windows")]
6077         extern "system" {
6078             fn MsiAdvertiseProductExA(szpackagepath: super::super::Foundation::PSTR, szscriptfilepath: super::super::Foundation::PSTR, sztransforms: super::super::Foundation::PSTR, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u32;
6079         }
6080         ::std::mem::transmute(MsiAdvertiseProductExA(szpackagepath.into_param().abi(), szscriptfilepath.into_param().abi(), sztransforms.into_param().abi(), ::std::mem::transmute(lgidlanguage), ::std::mem::transmute(dwplatform), ::std::mem::transmute(dwoptions)))
6081     }
6082     #[cfg(not(windows))]
6083     unimplemented!("Unsupported target OS");
6084 }
6085 #[cfg(feature = "Win32_Foundation")]
6086 #[inline]
MsiAdvertiseProductExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u326087 pub unsafe fn MsiAdvertiseProductExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u32 {
6088     #[cfg(windows)]
6089     {
6090         #[link(name = "windows")]
6091         extern "system" {
6092             fn MsiAdvertiseProductExW(szpackagepath: super::super::Foundation::PWSTR, szscriptfilepath: super::super::Foundation::PWSTR, sztransforms: super::super::Foundation::PWSTR, lgidlanguage: u16, dwplatform: u32, dwoptions: u32) -> u32;
6093         }
6094         ::std::mem::transmute(MsiAdvertiseProductExW(szpackagepath.into_param().abi(), szscriptfilepath.into_param().abi(), sztransforms.into_param().abi(), ::std::mem::transmute(lgidlanguage), ::std::mem::transmute(dwplatform), ::std::mem::transmute(dwoptions)))
6095     }
6096     #[cfg(not(windows))]
6097     unimplemented!("Unsupported target OS");
6098 }
6099 #[cfg(feature = "Win32_Foundation")]
6100 #[inline]
MsiAdvertiseProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16) -> u326101 pub unsafe fn MsiAdvertiseProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szscriptfilepath: Param1, sztransforms: Param2, lgidlanguage: u16) -> u32 {
6102     #[cfg(windows)]
6103     {
6104         #[link(name = "windows")]
6105         extern "system" {
6106             fn MsiAdvertiseProductW(szpackagepath: super::super::Foundation::PWSTR, szscriptfilepath: super::super::Foundation::PWSTR, sztransforms: super::super::Foundation::PWSTR, lgidlanguage: u16) -> u32;
6107         }
6108         ::std::mem::transmute(MsiAdvertiseProductW(szpackagepath.into_param().abi(), szscriptfilepath.into_param().abi(), sztransforms.into_param().abi(), ::std::mem::transmute(lgidlanguage)))
6109     }
6110     #[cfg(not(windows))]
6111     unimplemented!("Unsupported target OS");
6112 }
6113 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6114 #[inline]
MsiAdvertiseScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(szscriptfile: Param0, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: Param3) -> u326115 pub unsafe fn MsiAdvertiseScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(szscriptfile: Param0, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: Param3) -> u32 {
6116     #[cfg(windows)]
6117     {
6118         #[link(name = "windows")]
6119         extern "system" {
6120             fn MsiAdvertiseScriptA(szscriptfile: super::super::Foundation::PSTR, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: super::super::Foundation::BOOL) -> u32;
6121         }
6122         ::std::mem::transmute(MsiAdvertiseScriptA(szscriptfile.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(phregdata), fremoveitems.into_param().abi()))
6123     }
6124     #[cfg(not(windows))]
6125     unimplemented!("Unsupported target OS");
6126 }
6127 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6128 #[inline]
MsiAdvertiseScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(szscriptfile: Param0, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: Param3) -> u326129 pub unsafe fn MsiAdvertiseScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(szscriptfile: Param0, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: Param3) -> u32 {
6130     #[cfg(windows)]
6131     {
6132         #[link(name = "windows")]
6133         extern "system" {
6134             fn MsiAdvertiseScriptW(szscriptfile: super::super::Foundation::PWSTR, dwflags: u32, phregdata: *const super::Registry::HKEY, fremoveitems: super::super::Foundation::BOOL) -> u32;
6135         }
6136         ::std::mem::transmute(MsiAdvertiseScriptW(szscriptfile.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(phregdata), fremoveitems.into_param().abi()))
6137     }
6138     #[cfg(not(windows))]
6139     unimplemented!("Unsupported target OS");
6140 }
6141 #[cfg(feature = "Win32_Foundation")]
6142 #[inline]
MsiApplyMultiplePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpackages: Param0, szproductcode: Param1, szpropertieslist: Param2) -> u326143 pub unsafe fn MsiApplyMultiplePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpackages: Param0, szproductcode: Param1, szpropertieslist: Param2) -> u32 {
6144     #[cfg(windows)]
6145     {
6146         #[link(name = "windows")]
6147         extern "system" {
6148             fn MsiApplyMultiplePatchesA(szpatchpackages: super::super::Foundation::PSTR, szproductcode: super::super::Foundation::PSTR, szpropertieslist: super::super::Foundation::PSTR) -> u32;
6149         }
6150         ::std::mem::transmute(MsiApplyMultiplePatchesA(szpatchpackages.into_param().abi(), szproductcode.into_param().abi(), szpropertieslist.into_param().abi()))
6151     }
6152     #[cfg(not(windows))]
6153     unimplemented!("Unsupported target OS");
6154 }
6155 #[cfg(feature = "Win32_Foundation")]
6156 #[inline]
MsiApplyMultiplePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpackages: Param0, szproductcode: Param1, szpropertieslist: Param2) -> u326157 pub unsafe fn MsiApplyMultiplePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpackages: Param0, szproductcode: Param1, szpropertieslist: Param2) -> u32 {
6158     #[cfg(windows)]
6159     {
6160         #[link(name = "windows")]
6161         extern "system" {
6162             fn MsiApplyMultiplePatchesW(szpatchpackages: super::super::Foundation::PWSTR, szproductcode: super::super::Foundation::PWSTR, szpropertieslist: super::super::Foundation::PWSTR) -> u32;
6163         }
6164         ::std::mem::transmute(MsiApplyMultiplePatchesW(szpatchpackages.into_param().abi(), szproductcode.into_param().abi(), szpropertieslist.into_param().abi()))
6165     }
6166     #[cfg(not(windows))]
6167     unimplemented!("Unsupported target OS");
6168 }
6169 #[cfg(feature = "Win32_Foundation")]
6170 #[inline]
MsiApplyPatchA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpackage: Param0, szinstallpackage: Param1, einstalltype: INSTALLTYPE, szcommandline: Param3) -> u326171 pub unsafe fn MsiApplyPatchA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpackage: Param0, szinstallpackage: Param1, einstalltype: INSTALLTYPE, szcommandline: Param3) -> u32 {
6172     #[cfg(windows)]
6173     {
6174         #[link(name = "windows")]
6175         extern "system" {
6176             fn MsiApplyPatchA(szpatchpackage: super::super::Foundation::PSTR, szinstallpackage: super::super::Foundation::PSTR, einstalltype: INSTALLTYPE, szcommandline: super::super::Foundation::PSTR) -> u32;
6177         }
6178         ::std::mem::transmute(MsiApplyPatchA(szpatchpackage.into_param().abi(), szinstallpackage.into_param().abi(), ::std::mem::transmute(einstalltype), szcommandline.into_param().abi()))
6179     }
6180     #[cfg(not(windows))]
6181     unimplemented!("Unsupported target OS");
6182 }
6183 #[cfg(feature = "Win32_Foundation")]
6184 #[inline]
MsiApplyPatchW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpackage: Param0, szinstallpackage: Param1, einstalltype: INSTALLTYPE, szcommandline: Param3) -> u326185 pub unsafe fn MsiApplyPatchW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpackage: Param0, szinstallpackage: Param1, einstalltype: INSTALLTYPE, szcommandline: Param3) -> u32 {
6186     #[cfg(windows)]
6187     {
6188         #[link(name = "windows")]
6189         extern "system" {
6190             fn MsiApplyPatchW(szpatchpackage: super::super::Foundation::PWSTR, szinstallpackage: super::super::Foundation::PWSTR, einstalltype: INSTALLTYPE, szcommandline: super::super::Foundation::PWSTR) -> u32;
6191         }
6192         ::std::mem::transmute(MsiApplyPatchW(szpatchpackage.into_param().abi(), szinstallpackage.into_param().abi(), ::std::mem::transmute(einstalltype), szcommandline.into_param().abi()))
6193     }
6194     #[cfg(not(windows))]
6195     unimplemented!("Unsupported target OS");
6196 }
6197 #[cfg(feature = "Win32_Foundation")]
6198 #[inline]
MsiBeginTransactionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szname: Param0, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u326199 pub unsafe fn MsiBeginTransactionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szname: Param0, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32 {
6200     #[cfg(windows)]
6201     {
6202         #[link(name = "windows")]
6203         extern "system" {
6204             fn MsiBeginTransactionA(szname: super::super::Foundation::PSTR, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32;
6205         }
6206         ::std::mem::transmute(MsiBeginTransactionA(szname.into_param().abi(), ::std::mem::transmute(dwtransactionattributes), ::std::mem::transmute(phtransactionhandle), ::std::mem::transmute(phchangeofownerevent)))
6207     }
6208     #[cfg(not(windows))]
6209     unimplemented!("Unsupported target OS");
6210 }
6211 #[cfg(feature = "Win32_Foundation")]
6212 #[inline]
MsiBeginTransactionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szname: Param0, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u326213 pub unsafe fn MsiBeginTransactionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szname: Param0, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32 {
6214     #[cfg(windows)]
6215     {
6216         #[link(name = "windows")]
6217         extern "system" {
6218             fn MsiBeginTransactionW(szname: super::super::Foundation::PWSTR, dwtransactionattributes: u32, phtransactionhandle: *mut MSIHANDLE, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32;
6219         }
6220         ::std::mem::transmute(MsiBeginTransactionW(szname.into_param().abi(), ::std::mem::transmute(dwtransactionattributes), ::std::mem::transmute(phtransactionhandle), ::std::mem::transmute(phchangeofownerevent)))
6221     }
6222     #[cfg(not(windows))]
6223     unimplemented!("Unsupported target OS");
6224 }
6225 #[inline]
MsiCloseAllHandles() -> u326226 pub unsafe fn MsiCloseAllHandles() -> u32 {
6227     #[cfg(windows)]
6228     {
6229         #[link(name = "windows")]
6230         extern "system" {
6231             fn MsiCloseAllHandles() -> u32;
6232         }
6233         ::std::mem::transmute(MsiCloseAllHandles())
6234     }
6235     #[cfg(not(windows))]
6236     unimplemented!("Unsupported target OS");
6237 }
6238 #[inline]
MsiCloseHandle<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hany: Param0) -> u326239 pub unsafe fn MsiCloseHandle<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hany: Param0) -> u32 {
6240     #[cfg(windows)]
6241     {
6242         #[link(name = "windows")]
6243         extern "system" {
6244             fn MsiCloseHandle(hany: MSIHANDLE) -> u32;
6245         }
6246         ::std::mem::transmute(MsiCloseHandle(hany.into_param().abi()))
6247     }
6248     #[cfg(not(windows))]
6249     unimplemented!("Unsupported target OS");
6250 }
6251 #[cfg(feature = "Win32_Foundation")]
6252 #[inline]
MsiCollectUserInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0) -> u326253 pub unsafe fn MsiCollectUserInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0) -> u32 {
6254     #[cfg(windows)]
6255     {
6256         #[link(name = "windows")]
6257         extern "system" {
6258             fn MsiCollectUserInfoA(szproduct: super::super::Foundation::PSTR) -> u32;
6259         }
6260         ::std::mem::transmute(MsiCollectUserInfoA(szproduct.into_param().abi()))
6261     }
6262     #[cfg(not(windows))]
6263     unimplemented!("Unsupported target OS");
6264 }
6265 #[cfg(feature = "Win32_Foundation")]
6266 #[inline]
MsiCollectUserInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0) -> u326267 pub unsafe fn MsiCollectUserInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0) -> u32 {
6268     #[cfg(windows)]
6269     {
6270         #[link(name = "windows")]
6271         extern "system" {
6272             fn MsiCollectUserInfoW(szproduct: super::super::Foundation::PWSTR) -> u32;
6273         }
6274         ::std::mem::transmute(MsiCollectUserInfoW(szproduct.into_param().abi()))
6275     }
6276     #[cfg(not(windows))]
6277     unimplemented!("Unsupported target OS");
6278 }
6279 #[cfg(feature = "Win32_Foundation")]
6280 #[inline]
MsiConfigureFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, einstallstate: INSTALLSTATE) -> u326281 pub unsafe fn MsiConfigureFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, einstallstate: INSTALLSTATE) -> u32 {
6282     #[cfg(windows)]
6283     {
6284         #[link(name = "windows")]
6285         extern "system" {
6286             fn MsiConfigureFeatureA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR, einstallstate: INSTALLSTATE) -> u32;
6287         }
6288         ::std::mem::transmute(MsiConfigureFeatureA(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(einstallstate)))
6289     }
6290     #[cfg(not(windows))]
6291     unimplemented!("Unsupported target OS");
6292 }
6293 #[cfg(feature = "Win32_Foundation")]
6294 #[inline]
MsiConfigureFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, einstallstate: INSTALLSTATE) -> u326295 pub unsafe fn MsiConfigureFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, einstallstate: INSTALLSTATE) -> u32 {
6296     #[cfg(windows)]
6297     {
6298         #[link(name = "windows")]
6299         extern "system" {
6300             fn MsiConfigureFeatureW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR, einstallstate: INSTALLSTATE) -> u32;
6301         }
6302         ::std::mem::transmute(MsiConfigureFeatureW(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(einstallstate)))
6303     }
6304     #[cfg(not(windows))]
6305     unimplemented!("Unsupported target OS");
6306 }
6307 #[cfg(feature = "Win32_Foundation")]
6308 #[inline]
MsiConfigureProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u326309 pub unsafe fn MsiConfigureProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u32 {
6310     #[cfg(windows)]
6311     {
6312         #[link(name = "windows")]
6313         extern "system" {
6314             fn MsiConfigureProductA(szproduct: super::super::Foundation::PSTR, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u32;
6315         }
6316         ::std::mem::transmute(MsiConfigureProductA(szproduct.into_param().abi(), ::std::mem::transmute(iinstalllevel), ::std::mem::transmute(einstallstate)))
6317     }
6318     #[cfg(not(windows))]
6319     unimplemented!("Unsupported target OS");
6320 }
6321 #[cfg(feature = "Win32_Foundation")]
6322 #[inline]
MsiConfigureProductExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: Param3) -> u326323 pub unsafe fn MsiConfigureProductExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: Param3) -> u32 {
6324     #[cfg(windows)]
6325     {
6326         #[link(name = "windows")]
6327         extern "system" {
6328             fn MsiConfigureProductExA(szproduct: super::super::Foundation::PSTR, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: super::super::Foundation::PSTR) -> u32;
6329         }
6330         ::std::mem::transmute(MsiConfigureProductExA(szproduct.into_param().abi(), ::std::mem::transmute(iinstalllevel), ::std::mem::transmute(einstallstate), szcommandline.into_param().abi()))
6331     }
6332     #[cfg(not(windows))]
6333     unimplemented!("Unsupported target OS");
6334 }
6335 #[cfg(feature = "Win32_Foundation")]
6336 #[inline]
MsiConfigureProductExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: Param3) -> u326337 pub unsafe fn MsiConfigureProductExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: Param3) -> u32 {
6338     #[cfg(windows)]
6339     {
6340         #[link(name = "windows")]
6341         extern "system" {
6342             fn MsiConfigureProductExW(szproduct: super::super::Foundation::PWSTR, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE, szcommandline: super::super::Foundation::PWSTR) -> u32;
6343         }
6344         ::std::mem::transmute(MsiConfigureProductExW(szproduct.into_param().abi(), ::std::mem::transmute(iinstalllevel), ::std::mem::transmute(einstallstate), szcommandline.into_param().abi()))
6345     }
6346     #[cfg(not(windows))]
6347     unimplemented!("Unsupported target OS");
6348 }
6349 #[cfg(feature = "Win32_Foundation")]
6350 #[inline]
MsiConfigureProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u326351 pub unsafe fn MsiConfigureProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u32 {
6352     #[cfg(windows)]
6353     {
6354         #[link(name = "windows")]
6355         extern "system" {
6356             fn MsiConfigureProductW(szproduct: super::super::Foundation::PWSTR, iinstalllevel: INSTALLLEVEL, einstallstate: INSTALLSTATE) -> u32;
6357         }
6358         ::std::mem::transmute(MsiConfigureProductW(szproduct.into_param().abi(), ::std::mem::transmute(iinstalllevel), ::std::mem::transmute(einstallstate)))
6359     }
6360     #[cfg(not(windows))]
6361     unimplemented!("Unsupported target OS");
6362 }
6363 #[inline]
MsiCreateRecord(cparams: u32) -> MSIHANDLE6364 pub unsafe fn MsiCreateRecord(cparams: u32) -> MSIHANDLE {
6365     #[cfg(windows)]
6366     {
6367         #[link(name = "windows")]
6368         extern "system" {
6369             fn MsiCreateRecord(cparams: u32) -> MSIHANDLE;
6370         }
6371         ::std::mem::transmute(MsiCreateRecord(::std::mem::transmute(cparams)))
6372     }
6373     #[cfg(not(windows))]
6374     unimplemented!("Unsupported target OS");
6375 }
6376 #[cfg(feature = "Win32_Foundation")]
6377 #[inline]
MsiCreateTransformSummaryInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u326378 pub unsafe fn MsiCreateTransformSummaryInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u32 {
6379     #[cfg(windows)]
6380     {
6381         #[link(name = "windows")]
6382         extern "system" {
6383             fn MsiCreateTransformSummaryInfoA(hdatabase: MSIHANDLE, hdatabasereference: MSIHANDLE, sztransformfile: super::super::Foundation::PSTR, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u32;
6384         }
6385         ::std::mem::transmute(MsiCreateTransformSummaryInfoA(hdatabase.into_param().abi(), hdatabasereference.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ierrorconditions), ::std::mem::transmute(ivalidation)))
6386     }
6387     #[cfg(not(windows))]
6388     unimplemented!("Unsupported target OS");
6389 }
6390 #[cfg(feature = "Win32_Foundation")]
6391 #[inline]
MsiCreateTransformSummaryInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u326392 pub unsafe fn MsiCreateTransformSummaryInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u32 {
6393     #[cfg(windows)]
6394     {
6395         #[link(name = "windows")]
6396         extern "system" {
6397             fn MsiCreateTransformSummaryInfoW(hdatabase: MSIHANDLE, hdatabasereference: MSIHANDLE, sztransformfile: super::super::Foundation::PWSTR, ierrorconditions: MSITRANSFORM_ERROR, ivalidation: MSITRANSFORM_VALIDATE) -> u32;
6398         }
6399         ::std::mem::transmute(MsiCreateTransformSummaryInfoW(hdatabase.into_param().abi(), hdatabasereference.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ierrorconditions), ::std::mem::transmute(ivalidation)))
6400     }
6401     #[cfg(not(windows))]
6402     unimplemented!("Unsupported target OS");
6403 }
6404 #[cfg(feature = "Win32_Foundation")]
6405 #[inline]
MsiDatabaseApplyTransformA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztransformfile: Param1, ierrorconditions: MSITRANSFORM_ERROR) -> u326406 pub unsafe fn MsiDatabaseApplyTransformA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztransformfile: Param1, ierrorconditions: MSITRANSFORM_ERROR) -> u32 {
6407     #[cfg(windows)]
6408     {
6409         #[link(name = "windows")]
6410         extern "system" {
6411             fn MsiDatabaseApplyTransformA(hdatabase: MSIHANDLE, sztransformfile: super::super::Foundation::PSTR, ierrorconditions: MSITRANSFORM_ERROR) -> u32;
6412         }
6413         ::std::mem::transmute(MsiDatabaseApplyTransformA(hdatabase.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ierrorconditions)))
6414     }
6415     #[cfg(not(windows))]
6416     unimplemented!("Unsupported target OS");
6417 }
6418 #[cfg(feature = "Win32_Foundation")]
6419 #[inline]
MsiDatabaseApplyTransformW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztransformfile: Param1, ierrorconditions: MSITRANSFORM_ERROR) -> u326420 pub unsafe fn MsiDatabaseApplyTransformW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztransformfile: Param1, ierrorconditions: MSITRANSFORM_ERROR) -> u32 {
6421     #[cfg(windows)]
6422     {
6423         #[link(name = "windows")]
6424         extern "system" {
6425             fn MsiDatabaseApplyTransformW(hdatabase: MSIHANDLE, sztransformfile: super::super::Foundation::PWSTR, ierrorconditions: MSITRANSFORM_ERROR) -> u32;
6426         }
6427         ::std::mem::transmute(MsiDatabaseApplyTransformW(hdatabase.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ierrorconditions)))
6428     }
6429     #[cfg(not(windows))]
6430     unimplemented!("Unsupported target OS");
6431 }
6432 #[inline]
MsiDatabaseCommit<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0) -> u326433 pub unsafe fn MsiDatabaseCommit<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0) -> u32 {
6434     #[cfg(windows)]
6435     {
6436         #[link(name = "windows")]
6437         extern "system" {
6438             fn MsiDatabaseCommit(hdatabase: MSIHANDLE) -> u32;
6439         }
6440         ::std::mem::transmute(MsiDatabaseCommit(hdatabase.into_param().abi()))
6441     }
6442     #[cfg(not(windows))]
6443     unimplemented!("Unsupported target OS");
6444 }
6445 #[cfg(feature = "Win32_Foundation")]
6446 #[inline]
MsiDatabaseExportA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1, szfolderpath: Param2, szfilename: Param3) -> u326447 pub unsafe fn MsiDatabaseExportA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1, szfolderpath: Param2, szfilename: Param3) -> u32 {
6448     #[cfg(windows)]
6449     {
6450         #[link(name = "windows")]
6451         extern "system" {
6452             fn MsiDatabaseExportA(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PSTR, szfolderpath: super::super::Foundation::PSTR, szfilename: super::super::Foundation::PSTR) -> u32;
6453         }
6454         ::std::mem::transmute(MsiDatabaseExportA(hdatabase.into_param().abi(), sztablename.into_param().abi(), szfolderpath.into_param().abi(), szfilename.into_param().abi()))
6455     }
6456     #[cfg(not(windows))]
6457     unimplemented!("Unsupported target OS");
6458 }
6459 #[cfg(feature = "Win32_Foundation")]
6460 #[inline]
MsiDatabaseExportW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1, szfolderpath: Param2, szfilename: Param3) -> u326461 pub unsafe fn MsiDatabaseExportW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1, szfolderpath: Param2, szfilename: Param3) -> u32 {
6462     #[cfg(windows)]
6463     {
6464         #[link(name = "windows")]
6465         extern "system" {
6466             fn MsiDatabaseExportW(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PWSTR, szfolderpath: super::super::Foundation::PWSTR, szfilename: super::super::Foundation::PWSTR) -> u32;
6467         }
6468         ::std::mem::transmute(MsiDatabaseExportW(hdatabase.into_param().abi(), sztablename.into_param().abi(), szfolderpath.into_param().abi(), szfilename.into_param().abi()))
6469     }
6470     #[cfg(not(windows))]
6471     unimplemented!("Unsupported target OS");
6472 }
6473 #[cfg(feature = "Win32_Foundation")]
6474 #[inline]
MsiDatabaseGenerateTransformA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ireserved1: i32, ireserved2: i32) -> u326475 pub unsafe fn MsiDatabaseGenerateTransformA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ireserved1: i32, ireserved2: i32) -> u32 {
6476     #[cfg(windows)]
6477     {
6478         #[link(name = "windows")]
6479         extern "system" {
6480             fn MsiDatabaseGenerateTransformA(hdatabase: MSIHANDLE, hdatabasereference: MSIHANDLE, sztransformfile: super::super::Foundation::PSTR, ireserved1: i32, ireserved2: i32) -> u32;
6481         }
6482         ::std::mem::transmute(MsiDatabaseGenerateTransformA(hdatabase.into_param().abi(), hdatabasereference.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ireserved1), ::std::mem::transmute(ireserved2)))
6483     }
6484     #[cfg(not(windows))]
6485     unimplemented!("Unsupported target OS");
6486 }
6487 #[cfg(feature = "Win32_Foundation")]
6488 #[inline]
MsiDatabaseGenerateTransformW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ireserved1: i32, ireserved2: i32) -> u326489 pub unsafe fn MsiDatabaseGenerateTransformW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasereference: Param1, sztransformfile: Param2, ireserved1: i32, ireserved2: i32) -> u32 {
6490     #[cfg(windows)]
6491     {
6492         #[link(name = "windows")]
6493         extern "system" {
6494             fn MsiDatabaseGenerateTransformW(hdatabase: MSIHANDLE, hdatabasereference: MSIHANDLE, sztransformfile: super::super::Foundation::PWSTR, ireserved1: i32, ireserved2: i32) -> u32;
6495         }
6496         ::std::mem::transmute(MsiDatabaseGenerateTransformW(hdatabase.into_param().abi(), hdatabasereference.into_param().abi(), sztransformfile.into_param().abi(), ::std::mem::transmute(ireserved1), ::std::mem::transmute(ireserved2)))
6497     }
6498     #[cfg(not(windows))]
6499     unimplemented!("Unsupported target OS");
6500 }
6501 #[cfg(feature = "Win32_Foundation")]
6502 #[inline]
MsiDatabaseGetPrimaryKeysA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1, phrecord: *mut MSIHANDLE) -> u326503 pub unsafe fn MsiDatabaseGetPrimaryKeysA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1, phrecord: *mut MSIHANDLE) -> u32 {
6504     #[cfg(windows)]
6505     {
6506         #[link(name = "windows")]
6507         extern "system" {
6508             fn MsiDatabaseGetPrimaryKeysA(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PSTR, phrecord: *mut MSIHANDLE) -> u32;
6509         }
6510         ::std::mem::transmute(MsiDatabaseGetPrimaryKeysA(hdatabase.into_param().abi(), sztablename.into_param().abi(), ::std::mem::transmute(phrecord)))
6511     }
6512     #[cfg(not(windows))]
6513     unimplemented!("Unsupported target OS");
6514 }
6515 #[cfg(feature = "Win32_Foundation")]
6516 #[inline]
MsiDatabaseGetPrimaryKeysW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1, phrecord: *mut MSIHANDLE) -> u326517 pub unsafe fn MsiDatabaseGetPrimaryKeysW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1, phrecord: *mut MSIHANDLE) -> u32 {
6518     #[cfg(windows)]
6519     {
6520         #[link(name = "windows")]
6521         extern "system" {
6522             fn MsiDatabaseGetPrimaryKeysW(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PWSTR, phrecord: *mut MSIHANDLE) -> u32;
6523         }
6524         ::std::mem::transmute(MsiDatabaseGetPrimaryKeysW(hdatabase.into_param().abi(), sztablename.into_param().abi(), ::std::mem::transmute(phrecord)))
6525     }
6526     #[cfg(not(windows))]
6527     unimplemented!("Unsupported target OS");
6528 }
6529 #[cfg(feature = "Win32_Foundation")]
6530 #[inline]
MsiDatabaseImportA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szfolderpath: Param1, szfilename: Param2) -> u326531 pub unsafe fn MsiDatabaseImportA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szfolderpath: Param1, szfilename: Param2) -> u32 {
6532     #[cfg(windows)]
6533     {
6534         #[link(name = "windows")]
6535         extern "system" {
6536             fn MsiDatabaseImportA(hdatabase: MSIHANDLE, szfolderpath: super::super::Foundation::PSTR, szfilename: super::super::Foundation::PSTR) -> u32;
6537         }
6538         ::std::mem::transmute(MsiDatabaseImportA(hdatabase.into_param().abi(), szfolderpath.into_param().abi(), szfilename.into_param().abi()))
6539     }
6540     #[cfg(not(windows))]
6541     unimplemented!("Unsupported target OS");
6542 }
6543 #[cfg(feature = "Win32_Foundation")]
6544 #[inline]
MsiDatabaseImportW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szfolderpath: Param1, szfilename: Param2) -> u326545 pub unsafe fn MsiDatabaseImportW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szfolderpath: Param1, szfilename: Param2) -> u32 {
6546     #[cfg(windows)]
6547     {
6548         #[link(name = "windows")]
6549         extern "system" {
6550             fn MsiDatabaseImportW(hdatabase: MSIHANDLE, szfolderpath: super::super::Foundation::PWSTR, szfilename: super::super::Foundation::PWSTR) -> u32;
6551         }
6552         ::std::mem::transmute(MsiDatabaseImportW(hdatabase.into_param().abi(), szfolderpath.into_param().abi(), szfilename.into_param().abi()))
6553     }
6554     #[cfg(not(windows))]
6555     unimplemented!("Unsupported target OS");
6556 }
6557 #[cfg(feature = "Win32_Foundation")]
6558 #[inline]
MsiDatabaseIsTablePersistentA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1) -> MSICONDITION6559 pub unsafe fn MsiDatabaseIsTablePersistentA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, sztablename: Param1) -> MSICONDITION {
6560     #[cfg(windows)]
6561     {
6562         #[link(name = "windows")]
6563         extern "system" {
6564             fn MsiDatabaseIsTablePersistentA(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PSTR) -> MSICONDITION;
6565         }
6566         ::std::mem::transmute(MsiDatabaseIsTablePersistentA(hdatabase.into_param().abi(), sztablename.into_param().abi()))
6567     }
6568     #[cfg(not(windows))]
6569     unimplemented!("Unsupported target OS");
6570 }
6571 #[cfg(feature = "Win32_Foundation")]
6572 #[inline]
MsiDatabaseIsTablePersistentW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1) -> MSICONDITION6573 pub unsafe fn MsiDatabaseIsTablePersistentW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, sztablename: Param1) -> MSICONDITION {
6574     #[cfg(windows)]
6575     {
6576         #[link(name = "windows")]
6577         extern "system" {
6578             fn MsiDatabaseIsTablePersistentW(hdatabase: MSIHANDLE, sztablename: super::super::Foundation::PWSTR) -> MSICONDITION;
6579         }
6580         ::std::mem::transmute(MsiDatabaseIsTablePersistentW(hdatabase.into_param().abi(), sztablename.into_param().abi()))
6581     }
6582     #[cfg(not(windows))]
6583     unimplemented!("Unsupported target OS");
6584 }
6585 #[cfg(feature = "Win32_Foundation")]
6586 #[inline]
MsiDatabaseMergeA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasemerge: Param1, sztablename: Param2) -> u326587 pub unsafe fn MsiDatabaseMergeA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, hdatabasemerge: Param1, sztablename: Param2) -> u32 {
6588     #[cfg(windows)]
6589     {
6590         #[link(name = "windows")]
6591         extern "system" {
6592             fn MsiDatabaseMergeA(hdatabase: MSIHANDLE, hdatabasemerge: MSIHANDLE, sztablename: super::super::Foundation::PSTR) -> u32;
6593         }
6594         ::std::mem::transmute(MsiDatabaseMergeA(hdatabase.into_param().abi(), hdatabasemerge.into_param().abi(), sztablename.into_param().abi()))
6595     }
6596     #[cfg(not(windows))]
6597     unimplemented!("Unsupported target OS");
6598 }
6599 #[cfg(feature = "Win32_Foundation")]
6600 #[inline]
MsiDatabaseMergeW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasemerge: Param1, sztablename: Param2) -> u326601 pub unsafe fn MsiDatabaseMergeW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, hdatabasemerge: Param1, sztablename: Param2) -> u32 {
6602     #[cfg(windows)]
6603     {
6604         #[link(name = "windows")]
6605         extern "system" {
6606             fn MsiDatabaseMergeW(hdatabase: MSIHANDLE, hdatabasemerge: MSIHANDLE, sztablename: super::super::Foundation::PWSTR) -> u32;
6607         }
6608         ::std::mem::transmute(MsiDatabaseMergeW(hdatabase.into_param().abi(), hdatabasemerge.into_param().abi(), sztablename.into_param().abi()))
6609     }
6610     #[cfg(not(windows))]
6611     unimplemented!("Unsupported target OS");
6612 }
6613 #[cfg(feature = "Win32_Foundation")]
6614 #[inline]
MsiDatabaseOpenViewA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szquery: Param1, phview: *mut MSIHANDLE) -> u326615 pub unsafe fn MsiDatabaseOpenViewA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szquery: Param1, phview: *mut MSIHANDLE) -> u32 {
6616     #[cfg(windows)]
6617     {
6618         #[link(name = "windows")]
6619         extern "system" {
6620             fn MsiDatabaseOpenViewA(hdatabase: MSIHANDLE, szquery: super::super::Foundation::PSTR, phview: *mut MSIHANDLE) -> u32;
6621         }
6622         ::std::mem::transmute(MsiDatabaseOpenViewA(hdatabase.into_param().abi(), szquery.into_param().abi(), ::std::mem::transmute(phview)))
6623     }
6624     #[cfg(not(windows))]
6625     unimplemented!("Unsupported target OS");
6626 }
6627 #[cfg(feature = "Win32_Foundation")]
6628 #[inline]
MsiDatabaseOpenViewW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szquery: Param1, phview: *mut MSIHANDLE) -> u326629 pub unsafe fn MsiDatabaseOpenViewW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szquery: Param1, phview: *mut MSIHANDLE) -> u32 {
6630     #[cfg(windows)]
6631     {
6632         #[link(name = "windows")]
6633         extern "system" {
6634             fn MsiDatabaseOpenViewW(hdatabase: MSIHANDLE, szquery: super::super::Foundation::PWSTR, phview: *mut MSIHANDLE) -> u32;
6635         }
6636         ::std::mem::transmute(MsiDatabaseOpenViewW(hdatabase.into_param().abi(), szquery.into_param().abi(), ::std::mem::transmute(phview)))
6637     }
6638     #[cfg(not(windows))]
6639     unimplemented!("Unsupported target OS");
6640 }
6641 #[cfg(feature = "Win32_Foundation")]
6642 #[inline]
MsiDetermineApplicablePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductpackagepath: Param0, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u326643 pub unsafe fn MsiDetermineApplicablePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductpackagepath: Param0, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u32 {
6644     #[cfg(windows)]
6645     {
6646         #[link(name = "windows")]
6647         extern "system" {
6648             fn MsiDetermineApplicablePatchesA(szproductpackagepath: super::super::Foundation::PSTR, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u32;
6649         }
6650         ::std::mem::transmute(MsiDetermineApplicablePatchesA(szproductpackagepath.into_param().abi(), ::std::mem::transmute(cpatchinfo), ::std::mem::transmute(ppatchinfo)))
6651     }
6652     #[cfg(not(windows))]
6653     unimplemented!("Unsupported target OS");
6654 }
6655 #[cfg(feature = "Win32_Foundation")]
6656 #[inline]
MsiDetermineApplicablePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductpackagepath: Param0, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u326657 pub unsafe fn MsiDetermineApplicablePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductpackagepath: Param0, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u32 {
6658     #[cfg(windows)]
6659     {
6660         #[link(name = "windows")]
6661         extern "system" {
6662             fn MsiDetermineApplicablePatchesW(szproductpackagepath: super::super::Foundation::PWSTR, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u32;
6663         }
6664         ::std::mem::transmute(MsiDetermineApplicablePatchesW(szproductpackagepath.into_param().abi(), ::std::mem::transmute(cpatchinfo), ::std::mem::transmute(ppatchinfo)))
6665     }
6666     #[cfg(not(windows))]
6667     unimplemented!("Unsupported target OS");
6668 }
6669 #[cfg(feature = "Win32_Foundation")]
6670 #[inline]
MsiDeterminePatchSequenceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u326671 pub unsafe fn MsiDeterminePatchSequenceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u32 {
6672     #[cfg(windows)]
6673     {
6674         #[link(name = "windows")]
6675         extern "system" {
6676             fn MsiDeterminePatchSequenceA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOA) -> u32;
6677         }
6678         ::std::mem::transmute(MsiDeterminePatchSequenceA(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(cpatchinfo), ::std::mem::transmute(ppatchinfo)))
6679     }
6680     #[cfg(not(windows))]
6681     unimplemented!("Unsupported target OS");
6682 }
6683 #[cfg(feature = "Win32_Foundation")]
6684 #[inline]
MsiDeterminePatchSequenceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u326685 pub unsafe fn MsiDeterminePatchSequenceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u32 {
6686     #[cfg(windows)]
6687     {
6688         #[link(name = "windows")]
6689         extern "system" {
6690             fn MsiDeterminePatchSequenceW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, cpatchinfo: u32, ppatchinfo: *mut MSIPATCHSEQUENCEINFOW) -> u32;
6691         }
6692         ::std::mem::transmute(MsiDeterminePatchSequenceW(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(cpatchinfo), ::std::mem::transmute(ppatchinfo)))
6693     }
6694     #[cfg(not(windows))]
6695     unimplemented!("Unsupported target OS");
6696 }
6697 #[cfg(feature = "Win32_Foundation")]
6698 #[inline]
MsiDoActionA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szaction: Param1) -> u326699 pub unsafe fn MsiDoActionA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szaction: Param1) -> u32 {
6700     #[cfg(windows)]
6701     {
6702         #[link(name = "windows")]
6703         extern "system" {
6704             fn MsiDoActionA(hinstall: MSIHANDLE, szaction: super::super::Foundation::PSTR) -> u32;
6705         }
6706         ::std::mem::transmute(MsiDoActionA(hinstall.into_param().abi(), szaction.into_param().abi()))
6707     }
6708     #[cfg(not(windows))]
6709     unimplemented!("Unsupported target OS");
6710 }
6711 #[cfg(feature = "Win32_Foundation")]
6712 #[inline]
MsiDoActionW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szaction: Param1) -> u326713 pub unsafe fn MsiDoActionW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szaction: Param1) -> u32 {
6714     #[cfg(windows)]
6715     {
6716         #[link(name = "windows")]
6717         extern "system" {
6718             fn MsiDoActionW(hinstall: MSIHANDLE, szaction: super::super::Foundation::PWSTR) -> u32;
6719         }
6720         ::std::mem::transmute(MsiDoActionW(hinstall.into_param().abi(), szaction.into_param().abi()))
6721     }
6722     #[cfg(not(windows))]
6723     unimplemented!("Unsupported target OS");
6724 }
6725 #[cfg(feature = "Win32_Foundation")]
6726 #[inline]
MsiEnableLogA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwlogmode: INSTALLOGMODE, szlogfile: Param1, dwlogattributes: u32) -> u326727 pub unsafe fn MsiEnableLogA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwlogmode: INSTALLOGMODE, szlogfile: Param1, dwlogattributes: u32) -> u32 {
6728     #[cfg(windows)]
6729     {
6730         #[link(name = "windows")]
6731         extern "system" {
6732             fn MsiEnableLogA(dwlogmode: INSTALLOGMODE, szlogfile: super::super::Foundation::PSTR, dwlogattributes: u32) -> u32;
6733         }
6734         ::std::mem::transmute(MsiEnableLogA(::std::mem::transmute(dwlogmode), szlogfile.into_param().abi(), ::std::mem::transmute(dwlogattributes)))
6735     }
6736     #[cfg(not(windows))]
6737     unimplemented!("Unsupported target OS");
6738 }
6739 #[cfg(feature = "Win32_Foundation")]
6740 #[inline]
MsiEnableLogW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwlogmode: INSTALLOGMODE, szlogfile: Param1, dwlogattributes: u32) -> u326741 pub unsafe fn MsiEnableLogW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwlogmode: INSTALLOGMODE, szlogfile: Param1, dwlogattributes: u32) -> u32 {
6742     #[cfg(windows)]
6743     {
6744         #[link(name = "windows")]
6745         extern "system" {
6746             fn MsiEnableLogW(dwlogmode: INSTALLOGMODE, szlogfile: super::super::Foundation::PWSTR, dwlogattributes: u32) -> u32;
6747         }
6748         ::std::mem::transmute(MsiEnableLogW(::std::mem::transmute(dwlogmode), szlogfile.into_param().abi(), ::std::mem::transmute(dwlogattributes)))
6749     }
6750     #[cfg(not(windows))]
6751     unimplemented!("Unsupported target OS");
6752 }
6753 #[inline]
MsiEnableUIPreview<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0, phpreview: *mut MSIHANDLE) -> u326754 pub unsafe fn MsiEnableUIPreview<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0, phpreview: *mut MSIHANDLE) -> u32 {
6755     #[cfg(windows)]
6756     {
6757         #[link(name = "windows")]
6758         extern "system" {
6759             fn MsiEnableUIPreview(hdatabase: MSIHANDLE, phpreview: *mut MSIHANDLE) -> u32;
6760         }
6761         ::std::mem::transmute(MsiEnableUIPreview(hdatabase.into_param().abi(), ::std::mem::transmute(phpreview)))
6762     }
6763     #[cfg(not(windows))]
6764     unimplemented!("Unsupported target OS");
6765 }
6766 #[inline]
MsiEndTransaction(dwtransactionstate: MSITRANSACTIONSTATE) -> u326767 pub unsafe fn MsiEndTransaction(dwtransactionstate: MSITRANSACTIONSTATE) -> u32 {
6768     #[cfg(windows)]
6769     {
6770         #[link(name = "windows")]
6771         extern "system" {
6772             fn MsiEndTransaction(dwtransactionstate: MSITRANSACTIONSTATE) -> u32;
6773         }
6774         ::std::mem::transmute(MsiEndTransaction(::std::mem::transmute(dwtransactionstate)))
6775     }
6776     #[cfg(not(windows))]
6777     unimplemented!("Unsupported target OS");
6778 }
6779 #[cfg(feature = "Win32_Foundation")]
6780 #[inline]
MsiEnumClientsA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u326781 pub unsafe fn MsiEnumClientsA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32 {
6782     #[cfg(windows)]
6783     {
6784         #[link(name = "windows")]
6785         extern "system" {
6786             fn MsiEnumClientsA(szcomponent: super::super::Foundation::PSTR, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32;
6787         }
6788         ::std::mem::transmute(MsiEnumClientsA(szcomponent.into_param().abi(), ::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
6789     }
6790     #[cfg(not(windows))]
6791     unimplemented!("Unsupported target OS");
6792 }
6793 #[cfg(feature = "Win32_Foundation")]
6794 #[inline]
MsiEnumClientsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u326795 pub unsafe fn MsiEnumClientsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32 {
6796     #[cfg(windows)]
6797     {
6798         #[link(name = "windows")]
6799         extern "system" {
6800             fn MsiEnumClientsExA(szcomponent: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32;
6801         }
6802         ::std::mem::transmute(MsiEnumClientsExA(szcomponent.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwproductindex), ::std::mem::transmute(szproductbuf), ::std::mem::transmute(pdwinstalledcontext), ::std::mem::transmute(szsid), ::std::mem::transmute(pcchsid)))
6803     }
6804     #[cfg(not(windows))]
6805     unimplemented!("Unsupported target OS");
6806 }
6807 #[cfg(feature = "Win32_Foundation")]
6808 #[inline]
MsiEnumClientsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u326809 pub unsafe fn MsiEnumClientsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32 {
6810     #[cfg(windows)]
6811     {
6812         #[link(name = "windows")]
6813         extern "system" {
6814             fn MsiEnumClientsExW(szcomponent: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwproductindex: u32, szproductbuf: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32;
6815         }
6816         ::std::mem::transmute(MsiEnumClientsExW(szcomponent.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwproductindex), ::std::mem::transmute(szproductbuf), ::std::mem::transmute(pdwinstalledcontext), ::std::mem::transmute(szsid), ::std::mem::transmute(pcchsid)))
6817     }
6818     #[cfg(not(windows))]
6819     unimplemented!("Unsupported target OS");
6820 }
6821 #[cfg(feature = "Win32_Foundation")]
6822 #[inline]
MsiEnumClientsW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u326823 pub unsafe fn MsiEnumClientsW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32 {
6824     #[cfg(windows)]
6825     {
6826         #[link(name = "windows")]
6827         extern "system" {
6828             fn MsiEnumClientsW(szcomponent: super::super::Foundation::PWSTR, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32;
6829         }
6830         ::std::mem::transmute(MsiEnumClientsW(szcomponent.into_param().abi(), ::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
6831     }
6832     #[cfg(not(windows))]
6833     unimplemented!("Unsupported target OS");
6834 }
6835 #[cfg(feature = "Win32_Foundation")]
6836 #[inline]
MsiEnumComponentCostsA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u326837 pub unsafe fn MsiEnumComponentCostsA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u32 {
6838     #[cfg(windows)]
6839     {
6840         #[link(name = "windows")]
6841         extern "system" {
6842             fn MsiEnumComponentCostsA(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PSTR, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u32;
6843         }
6844         ::std::mem::transmute(MsiEnumComponentCostsA(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(dwindex), ::std::mem::transmute(istate), ::std::mem::transmute(szdrivebuf), ::std::mem::transmute(pcchdrivebuf), ::std::mem::transmute(picost), ::std::mem::transmute(pitempcost)))
6845     }
6846     #[cfg(not(windows))]
6847     unimplemented!("Unsupported target OS");
6848 }
6849 #[cfg(feature = "Win32_Foundation")]
6850 #[inline]
MsiEnumComponentCostsW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PWSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u326851 pub unsafe fn MsiEnumComponentCostsW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PWSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u32 {
6852     #[cfg(windows)]
6853     {
6854         #[link(name = "windows")]
6855         extern "system" {
6856             fn MsiEnumComponentCostsW(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PWSTR, dwindex: u32, istate: INSTALLSTATE, szdrivebuf: super::super::Foundation::PWSTR, pcchdrivebuf: *mut u32, picost: *mut i32, pitempcost: *mut i32) -> u32;
6857         }
6858         ::std::mem::transmute(MsiEnumComponentCostsW(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(dwindex), ::std::mem::transmute(istate), ::std::mem::transmute(szdrivebuf), ::std::mem::transmute(pcchdrivebuf), ::std::mem::transmute(picost), ::std::mem::transmute(pitempcost)))
6859     }
6860     #[cfg(not(windows))]
6861     unimplemented!("Unsupported target OS");
6862 }
6863 #[cfg(feature = "Win32_Foundation")]
6864 #[inline]
MsiEnumComponentQualifiersA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, iindex: u32, lpqualifierbuf: super::super::Foundation::PSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PSTR, pcchapplicationdatabuf: *mut u32) -> u326865 pub unsafe fn MsiEnumComponentQualifiersA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, iindex: u32, lpqualifierbuf: super::super::Foundation::PSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PSTR, pcchapplicationdatabuf: *mut u32) -> u32 {
6866     #[cfg(windows)]
6867     {
6868         #[link(name = "windows")]
6869         extern "system" {
6870             fn MsiEnumComponentQualifiersA(szcomponent: super::super::Foundation::PSTR, iindex: u32, lpqualifierbuf: super::super::Foundation::PSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PSTR, pcchapplicationdatabuf: *mut u32) -> u32;
6871         }
6872         ::std::mem::transmute(MsiEnumComponentQualifiersA(szcomponent.into_param().abi(), ::std::mem::transmute(iindex), ::std::mem::transmute(lpqualifierbuf), ::std::mem::transmute(pcchqualifierbuf), ::std::mem::transmute(lpapplicationdatabuf), ::std::mem::transmute(pcchapplicationdatabuf)))
6873     }
6874     #[cfg(not(windows))]
6875     unimplemented!("Unsupported target OS");
6876 }
6877 #[cfg(feature = "Win32_Foundation")]
6878 #[inline]
MsiEnumComponentQualifiersW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, iindex: u32, lpqualifierbuf: super::super::Foundation::PWSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PWSTR, pcchapplicationdatabuf: *mut u32) -> u326879 pub unsafe fn MsiEnumComponentQualifiersW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, iindex: u32, lpqualifierbuf: super::super::Foundation::PWSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PWSTR, pcchapplicationdatabuf: *mut u32) -> u32 {
6880     #[cfg(windows)]
6881     {
6882         #[link(name = "windows")]
6883         extern "system" {
6884             fn MsiEnumComponentQualifiersW(szcomponent: super::super::Foundation::PWSTR, iindex: u32, lpqualifierbuf: super::super::Foundation::PWSTR, pcchqualifierbuf: *mut u32, lpapplicationdatabuf: super::super::Foundation::PWSTR, pcchapplicationdatabuf: *mut u32) -> u32;
6885         }
6886         ::std::mem::transmute(MsiEnumComponentQualifiersW(szcomponent.into_param().abi(), ::std::mem::transmute(iindex), ::std::mem::transmute(lpqualifierbuf), ::std::mem::transmute(pcchqualifierbuf), ::std::mem::transmute(lpapplicationdatabuf), ::std::mem::transmute(pcchapplicationdatabuf)))
6887     }
6888     #[cfg(not(windows))]
6889     unimplemented!("Unsupported target OS");
6890 }
6891 #[cfg(feature = "Win32_Foundation")]
6892 #[inline]
MsiEnumComponentsA(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PSTR) -> u326893 pub unsafe fn MsiEnumComponentsA(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PSTR) -> u32 {
6894     #[cfg(windows)]
6895     {
6896         #[link(name = "windows")]
6897         extern "system" {
6898             fn MsiEnumComponentsA(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PSTR) -> u32;
6899         }
6900         ::std::mem::transmute(MsiEnumComponentsA(::std::mem::transmute(icomponentindex), ::std::mem::transmute(lpcomponentbuf)))
6901     }
6902     #[cfg(not(windows))]
6903     unimplemented!("Unsupported target OS");
6904 }
6905 #[cfg(feature = "Win32_Foundation")]
6906 #[inline]
MsiEnumComponentsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szusersid: Param0, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u326907 pub unsafe fn MsiEnumComponentsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szusersid: Param0, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32 {
6908     #[cfg(windows)]
6909     {
6910         #[link(name = "windows")]
6911         extern "system" {
6912             fn MsiEnumComponentsExA(szusersid: super::super::Foundation::PSTR, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32;
6913         }
6914         ::std::mem::transmute(MsiEnumComponentsExA(szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwindex), ::std::mem::transmute(szinstalledcomponentcode), ::std::mem::transmute(pdwinstalledcontext), ::std::mem::transmute(szsid), ::std::mem::transmute(pcchsid)))
6915     }
6916     #[cfg(not(windows))]
6917     unimplemented!("Unsupported target OS");
6918 }
6919 #[cfg(feature = "Win32_Foundation")]
6920 #[inline]
MsiEnumComponentsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szusersid: Param0, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u326921 pub unsafe fn MsiEnumComponentsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szusersid: Param0, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32 {
6922     #[cfg(windows)]
6923     {
6924         #[link(name = "windows")]
6925         extern "system" {
6926             fn MsiEnumComponentsExW(szusersid: super::super::Foundation::PWSTR, dwcontext: u32, dwindex: u32, szinstalledcomponentcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32;
6927         }
6928         ::std::mem::transmute(MsiEnumComponentsExW(szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwindex), ::std::mem::transmute(szinstalledcomponentcode), ::std::mem::transmute(pdwinstalledcontext), ::std::mem::transmute(szsid), ::std::mem::transmute(pcchsid)))
6929     }
6930     #[cfg(not(windows))]
6931     unimplemented!("Unsupported target OS");
6932 }
6933 #[cfg(feature = "Win32_Foundation")]
6934 #[inline]
MsiEnumComponentsW(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PWSTR) -> u326935 pub unsafe fn MsiEnumComponentsW(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PWSTR) -> u32 {
6936     #[cfg(windows)]
6937     {
6938         #[link(name = "windows")]
6939         extern "system" {
6940             fn MsiEnumComponentsW(icomponentindex: u32, lpcomponentbuf: super::super::Foundation::PWSTR) -> u32;
6941         }
6942         ::std::mem::transmute(MsiEnumComponentsW(::std::mem::transmute(icomponentindex), ::std::mem::transmute(lpcomponentbuf)))
6943     }
6944     #[cfg(not(windows))]
6945     unimplemented!("Unsupported target OS");
6946 }
6947 #[cfg(feature = "Win32_Foundation")]
6948 #[inline]
MsiEnumFeaturesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PSTR, lpparentbuf: super::super::Foundation::PSTR) -> u326949 pub unsafe fn MsiEnumFeaturesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PSTR, lpparentbuf: super::super::Foundation::PSTR) -> u32 {
6950     #[cfg(windows)]
6951     {
6952         #[link(name = "windows")]
6953         extern "system" {
6954             fn MsiEnumFeaturesA(szproduct: super::super::Foundation::PSTR, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PSTR, lpparentbuf: super::super::Foundation::PSTR) -> u32;
6955         }
6956         ::std::mem::transmute(MsiEnumFeaturesA(szproduct.into_param().abi(), ::std::mem::transmute(ifeatureindex), ::std::mem::transmute(lpfeaturebuf), ::std::mem::transmute(lpparentbuf)))
6957     }
6958     #[cfg(not(windows))]
6959     unimplemented!("Unsupported target OS");
6960 }
6961 #[cfg(feature = "Win32_Foundation")]
6962 #[inline]
MsiEnumFeaturesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PWSTR, lpparentbuf: super::super::Foundation::PWSTR) -> u326963 pub unsafe fn MsiEnumFeaturesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PWSTR, lpparentbuf: super::super::Foundation::PWSTR) -> u32 {
6964     #[cfg(windows)]
6965     {
6966         #[link(name = "windows")]
6967         extern "system" {
6968             fn MsiEnumFeaturesW(szproduct: super::super::Foundation::PWSTR, ifeatureindex: u32, lpfeaturebuf: super::super::Foundation::PWSTR, lpparentbuf: super::super::Foundation::PWSTR) -> u32;
6969         }
6970         ::std::mem::transmute(MsiEnumFeaturesW(szproduct.into_param().abi(), ::std::mem::transmute(ifeatureindex), ::std::mem::transmute(lpfeaturebuf), ::std::mem::transmute(lpparentbuf)))
6971     }
6972     #[cfg(not(windows))]
6973     unimplemented!("Unsupported target OS");
6974 }
6975 #[cfg(feature = "Win32_Foundation")]
6976 #[inline]
MsiEnumPatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, ipatchindex: u32, lppatchbuf: super::super::Foundation::PSTR, lptransformsbuf: super::super::Foundation::PSTR, pcchtransformsbuf: *mut u32) -> u326977 pub unsafe fn MsiEnumPatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, ipatchindex: u32, lppatchbuf: super::super::Foundation::PSTR, lptransformsbuf: super::super::Foundation::PSTR, pcchtransformsbuf: *mut u32) -> u32 {
6978     #[cfg(windows)]
6979     {
6980         #[link(name = "windows")]
6981         extern "system" {
6982             fn MsiEnumPatchesA(szproduct: super::super::Foundation::PSTR, ipatchindex: u32, lppatchbuf: super::super::Foundation::PSTR, lptransformsbuf: super::super::Foundation::PSTR, pcchtransformsbuf: *mut u32) -> u32;
6983         }
6984         ::std::mem::transmute(MsiEnumPatchesA(szproduct.into_param().abi(), ::std::mem::transmute(ipatchindex), ::std::mem::transmute(lppatchbuf), ::std::mem::transmute(lptransformsbuf), ::std::mem::transmute(pcchtransformsbuf)))
6985     }
6986     #[cfg(not(windows))]
6987     unimplemented!("Unsupported target OS");
6988 }
6989 #[cfg(feature = "Win32_Foundation")]
6990 #[inline]
MsiEnumPatchesExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwfilter: u32, dwindex: u32, szpatchcode: super::super::Foundation::PSTR, sztargetproductcode: super::super::Foundation::PSTR, pdwtargetproductcontext: *mut MSIINSTALLCONTEXT, sztargetusersid: super::super::Foundation::PSTR, pcchtargetusersid: *mut u32, ) -> u326991 pub unsafe fn MsiEnumPatchesExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
6992     szproductcode: Param0,
6993     szusersid: Param1,
6994     dwcontext: u32,
6995     dwfilter: u32,
6996     dwindex: u32,
6997     szpatchcode: super::super::Foundation::PSTR,
6998     sztargetproductcode: super::super::Foundation::PSTR,
6999     pdwtargetproductcontext: *mut MSIINSTALLCONTEXT,
7000     sztargetusersid: super::super::Foundation::PSTR,
7001     pcchtargetusersid: *mut u32,
7002 ) -> u32 {
7003     #[cfg(windows)]
7004     {
7005         #[link(name = "windows")]
7006         extern "system" {
7007             fn MsiEnumPatchesExA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: u32, dwfilter: u32, dwindex: u32, szpatchcode: super::super::Foundation::PSTR, sztargetproductcode: super::super::Foundation::PSTR, pdwtargetproductcontext: *mut MSIINSTALLCONTEXT, sztargetusersid: super::super::Foundation::PSTR, pcchtargetusersid: *mut u32) -> u32;
7008         }
7009         ::std::mem::transmute(MsiEnumPatchesExA(
7010             szproductcode.into_param().abi(),
7011             szusersid.into_param().abi(),
7012             ::std::mem::transmute(dwcontext),
7013             ::std::mem::transmute(dwfilter),
7014             ::std::mem::transmute(dwindex),
7015             ::std::mem::transmute(szpatchcode),
7016             ::std::mem::transmute(sztargetproductcode),
7017             ::std::mem::transmute(pdwtargetproductcontext),
7018             ::std::mem::transmute(sztargetusersid),
7019             ::std::mem::transmute(pcchtargetusersid),
7020         ))
7021     }
7022     #[cfg(not(windows))]
7023     unimplemented!("Unsupported target OS");
7024 }
7025 #[cfg(feature = "Win32_Foundation")]
7026 #[inline]
MsiEnumPatchesExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwfilter: u32, dwindex: u32, szpatchcode: super::super::Foundation::PWSTR, sztargetproductcode: super::super::Foundation::PWSTR, pdwtargetproductcontext: *mut MSIINSTALLCONTEXT, sztargetusersid: super::super::Foundation::PWSTR, pcchtargetusersid: *mut u32, ) -> u327027 pub unsafe fn MsiEnumPatchesExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
7028     szproductcode: Param0,
7029     szusersid: Param1,
7030     dwcontext: u32,
7031     dwfilter: u32,
7032     dwindex: u32,
7033     szpatchcode: super::super::Foundation::PWSTR,
7034     sztargetproductcode: super::super::Foundation::PWSTR,
7035     pdwtargetproductcontext: *mut MSIINSTALLCONTEXT,
7036     sztargetusersid: super::super::Foundation::PWSTR,
7037     pcchtargetusersid: *mut u32,
7038 ) -> u32 {
7039     #[cfg(windows)]
7040     {
7041         #[link(name = "windows")]
7042         extern "system" {
7043             fn MsiEnumPatchesExW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: u32, dwfilter: u32, dwindex: u32, szpatchcode: super::super::Foundation::PWSTR, sztargetproductcode: super::super::Foundation::PWSTR, pdwtargetproductcontext: *mut MSIINSTALLCONTEXT, sztargetusersid: super::super::Foundation::PWSTR, pcchtargetusersid: *mut u32) -> u32;
7044         }
7045         ::std::mem::transmute(MsiEnumPatchesExW(
7046             szproductcode.into_param().abi(),
7047             szusersid.into_param().abi(),
7048             ::std::mem::transmute(dwcontext),
7049             ::std::mem::transmute(dwfilter),
7050             ::std::mem::transmute(dwindex),
7051             ::std::mem::transmute(szpatchcode),
7052             ::std::mem::transmute(sztargetproductcode),
7053             ::std::mem::transmute(pdwtargetproductcontext),
7054             ::std::mem::transmute(sztargetusersid),
7055             ::std::mem::transmute(pcchtargetusersid),
7056         ))
7057     }
7058     #[cfg(not(windows))]
7059     unimplemented!("Unsupported target OS");
7060 }
7061 #[cfg(feature = "Win32_Foundation")]
7062 #[inline]
MsiEnumPatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, ipatchindex: u32, lppatchbuf: super::super::Foundation::PWSTR, lptransformsbuf: super::super::Foundation::PWSTR, pcchtransformsbuf: *mut u32) -> u327063 pub unsafe fn MsiEnumPatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, ipatchindex: u32, lppatchbuf: super::super::Foundation::PWSTR, lptransformsbuf: super::super::Foundation::PWSTR, pcchtransformsbuf: *mut u32) -> u32 {
7064     #[cfg(windows)]
7065     {
7066         #[link(name = "windows")]
7067         extern "system" {
7068             fn MsiEnumPatchesW(szproduct: super::super::Foundation::PWSTR, ipatchindex: u32, lppatchbuf: super::super::Foundation::PWSTR, lptransformsbuf: super::super::Foundation::PWSTR, pcchtransformsbuf: *mut u32) -> u32;
7069         }
7070         ::std::mem::transmute(MsiEnumPatchesW(szproduct.into_param().abi(), ::std::mem::transmute(ipatchindex), ::std::mem::transmute(lppatchbuf), ::std::mem::transmute(lptransformsbuf), ::std::mem::transmute(pcchtransformsbuf)))
7071     }
7072     #[cfg(not(windows))]
7073     unimplemented!("Unsupported target OS");
7074 }
7075 #[cfg(feature = "Win32_Foundation")]
7076 #[inline]
MsiEnumProductsA(iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u327077 pub unsafe fn MsiEnumProductsA(iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32 {
7078     #[cfg(windows)]
7079     {
7080         #[link(name = "windows")]
7081         extern "system" {
7082             fn MsiEnumProductsA(iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32;
7083         }
7084         ::std::mem::transmute(MsiEnumProductsA(::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
7085     }
7086     #[cfg(not(windows))]
7087     unimplemented!("Unsupported target OS");
7088 }
7089 #[cfg(feature = "Win32_Foundation")]
7090 #[inline]
MsiEnumProductsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u327091 pub unsafe fn MsiEnumProductsExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32 {
7092     #[cfg(windows)]
7093     {
7094         #[link(name = "windows")]
7095         extern "system" {
7096             fn MsiEnumProductsExA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PSTR, pcchsid: *mut u32) -> u32;
7097         }
7098         ::std::mem::transmute(MsiEnumProductsExA(
7099             szproductcode.into_param().abi(),
7100             szusersid.into_param().abi(),
7101             ::std::mem::transmute(dwcontext),
7102             ::std::mem::transmute(dwindex),
7103             ::std::mem::transmute(szinstalledproductcode),
7104             ::std::mem::transmute(pdwinstalledcontext),
7105             ::std::mem::transmute(szsid),
7106             ::std::mem::transmute(pcchsid),
7107         ))
7108     }
7109     #[cfg(not(windows))]
7110     unimplemented!("Unsupported target OS");
7111 }
7112 #[cfg(feature = "Win32_Foundation")]
7113 #[inline]
MsiEnumProductsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u327114 pub unsafe fn MsiEnumProductsExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32 {
7115     #[cfg(windows)]
7116     {
7117         #[link(name = "windows")]
7118         extern "system" {
7119             fn MsiEnumProductsExW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: u32, dwindex: u32, szinstalledproductcode: super::super::Foundation::PWSTR, pdwinstalledcontext: *mut MSIINSTALLCONTEXT, szsid: super::super::Foundation::PWSTR, pcchsid: *mut u32) -> u32;
7120         }
7121         ::std::mem::transmute(MsiEnumProductsExW(
7122             szproductcode.into_param().abi(),
7123             szusersid.into_param().abi(),
7124             ::std::mem::transmute(dwcontext),
7125             ::std::mem::transmute(dwindex),
7126             ::std::mem::transmute(szinstalledproductcode),
7127             ::std::mem::transmute(pdwinstalledcontext),
7128             ::std::mem::transmute(szsid),
7129             ::std::mem::transmute(pcchsid),
7130         ))
7131     }
7132     #[cfg(not(windows))]
7133     unimplemented!("Unsupported target OS");
7134 }
7135 #[cfg(feature = "Win32_Foundation")]
7136 #[inline]
MsiEnumProductsW(iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u327137 pub unsafe fn MsiEnumProductsW(iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32 {
7138     #[cfg(windows)]
7139     {
7140         #[link(name = "windows")]
7141         extern "system" {
7142             fn MsiEnumProductsW(iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32;
7143         }
7144         ::std::mem::transmute(MsiEnumProductsW(::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
7145     }
7146     #[cfg(not(windows))]
7147     unimplemented!("Unsupported target OS");
7148 }
7149 #[cfg(feature = "Win32_Foundation")]
7150 #[inline]
MsiEnumRelatedProductsA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpupgradecode: Param0, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u327151 pub unsafe fn MsiEnumRelatedProductsA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpupgradecode: Param0, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32 {
7152     #[cfg(windows)]
7153     {
7154         #[link(name = "windows")]
7155         extern "system" {
7156             fn MsiEnumRelatedProductsA(lpupgradecode: super::super::Foundation::PSTR, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PSTR) -> u32;
7157         }
7158         ::std::mem::transmute(MsiEnumRelatedProductsA(lpupgradecode.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
7159     }
7160     #[cfg(not(windows))]
7161     unimplemented!("Unsupported target OS");
7162 }
7163 #[cfg(feature = "Win32_Foundation")]
7164 #[inline]
MsiEnumRelatedProductsW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpupgradecode: Param0, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u327165 pub unsafe fn MsiEnumRelatedProductsW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpupgradecode: Param0, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32 {
7166     #[cfg(windows)]
7167     {
7168         #[link(name = "windows")]
7169         extern "system" {
7170             fn MsiEnumRelatedProductsW(lpupgradecode: super::super::Foundation::PWSTR, dwreserved: u32, iproductindex: u32, lpproductbuf: super::super::Foundation::PWSTR) -> u32;
7171         }
7172         ::std::mem::transmute(MsiEnumRelatedProductsW(lpupgradecode.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(iproductindex), ::std::mem::transmute(lpproductbuf)))
7173     }
7174     #[cfg(not(windows))]
7175     unimplemented!("Unsupported target OS");
7176 }
7177 #[cfg(feature = "Win32_Foundation")]
7178 #[inline]
MsiEvaluateConditionA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcondition: Param1) -> MSICONDITION7179 pub unsafe fn MsiEvaluateConditionA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcondition: Param1) -> MSICONDITION {
7180     #[cfg(windows)]
7181     {
7182         #[link(name = "windows")]
7183         extern "system" {
7184             fn MsiEvaluateConditionA(hinstall: MSIHANDLE, szcondition: super::super::Foundation::PSTR) -> MSICONDITION;
7185         }
7186         ::std::mem::transmute(MsiEvaluateConditionA(hinstall.into_param().abi(), szcondition.into_param().abi()))
7187     }
7188     #[cfg(not(windows))]
7189     unimplemented!("Unsupported target OS");
7190 }
7191 #[cfg(feature = "Win32_Foundation")]
7192 #[inline]
MsiEvaluateConditionW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcondition: Param1) -> MSICONDITION7193 pub unsafe fn MsiEvaluateConditionW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcondition: Param1) -> MSICONDITION {
7194     #[cfg(windows)]
7195     {
7196         #[link(name = "windows")]
7197         extern "system" {
7198             fn MsiEvaluateConditionW(hinstall: MSIHANDLE, szcondition: super::super::Foundation::PWSTR) -> MSICONDITION;
7199         }
7200         ::std::mem::transmute(MsiEvaluateConditionW(hinstall.into_param().abi(), szcondition.into_param().abi()))
7201     }
7202     #[cfg(not(windows))]
7203     unimplemented!("Unsupported target OS");
7204 }
7205 #[cfg(feature = "Win32_Foundation")]
7206 #[inline]
MsiExtractPatchXMLDataA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpath: Param0, dwreserved: u32, szxmldata: super::super::Foundation::PSTR, pcchxmldata: *mut u32) -> u327207 pub unsafe fn MsiExtractPatchXMLDataA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchpath: Param0, dwreserved: u32, szxmldata: super::super::Foundation::PSTR, pcchxmldata: *mut u32) -> u32 {
7208     #[cfg(windows)]
7209     {
7210         #[link(name = "windows")]
7211         extern "system" {
7212             fn MsiExtractPatchXMLDataA(szpatchpath: super::super::Foundation::PSTR, dwreserved: u32, szxmldata: super::super::Foundation::PSTR, pcchxmldata: *mut u32) -> u32;
7213         }
7214         ::std::mem::transmute(MsiExtractPatchXMLDataA(szpatchpath.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(szxmldata), ::std::mem::transmute(pcchxmldata)))
7215     }
7216     #[cfg(not(windows))]
7217     unimplemented!("Unsupported target OS");
7218 }
7219 #[cfg(feature = "Win32_Foundation")]
7220 #[inline]
MsiExtractPatchXMLDataW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpath: Param0, dwreserved: u32, szxmldata: super::super::Foundation::PWSTR, pcchxmldata: *mut u32) -> u327221 pub unsafe fn MsiExtractPatchXMLDataW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchpath: Param0, dwreserved: u32, szxmldata: super::super::Foundation::PWSTR, pcchxmldata: *mut u32) -> u32 {
7222     #[cfg(windows)]
7223     {
7224         #[link(name = "windows")]
7225         extern "system" {
7226             fn MsiExtractPatchXMLDataW(szpatchpath: super::super::Foundation::PWSTR, dwreserved: u32, szxmldata: super::super::Foundation::PWSTR, pcchxmldata: *mut u32) -> u32;
7227         }
7228         ::std::mem::transmute(MsiExtractPatchXMLDataW(szpatchpath.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(szxmldata), ::std::mem::transmute(pcchxmldata)))
7229     }
7230     #[cfg(not(windows))]
7231     unimplemented!("Unsupported target OS");
7232 }
7233 #[cfg(feature = "Win32_Foundation")]
7234 #[inline]
MsiFormatRecordA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, hrecord: Param1, szresultbuf: super::super::Foundation::PSTR, pcchresultbuf: *mut u32) -> u327235 pub unsafe fn MsiFormatRecordA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, hrecord: Param1, szresultbuf: super::super::Foundation::PSTR, pcchresultbuf: *mut u32) -> u32 {
7236     #[cfg(windows)]
7237     {
7238         #[link(name = "windows")]
7239         extern "system" {
7240             fn MsiFormatRecordA(hinstall: MSIHANDLE, hrecord: MSIHANDLE, szresultbuf: super::super::Foundation::PSTR, pcchresultbuf: *mut u32) -> u32;
7241         }
7242         ::std::mem::transmute(MsiFormatRecordA(hinstall.into_param().abi(), hrecord.into_param().abi(), ::std::mem::transmute(szresultbuf), ::std::mem::transmute(pcchresultbuf)))
7243     }
7244     #[cfg(not(windows))]
7245     unimplemented!("Unsupported target OS");
7246 }
7247 #[cfg(feature = "Win32_Foundation")]
7248 #[inline]
MsiFormatRecordW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, hrecord: Param1, szresultbuf: super::super::Foundation::PWSTR, pcchresultbuf: *mut u32) -> u327249 pub unsafe fn MsiFormatRecordW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, hrecord: Param1, szresultbuf: super::super::Foundation::PWSTR, pcchresultbuf: *mut u32) -> u32 {
7250     #[cfg(windows)]
7251     {
7252         #[link(name = "windows")]
7253         extern "system" {
7254             fn MsiFormatRecordW(hinstall: MSIHANDLE, hrecord: MSIHANDLE, szresultbuf: super::super::Foundation::PWSTR, pcchresultbuf: *mut u32) -> u32;
7255         }
7256         ::std::mem::transmute(MsiFormatRecordW(hinstall.into_param().abi(), hrecord.into_param().abi(), ::std::mem::transmute(szresultbuf), ::std::mem::transmute(pcchresultbuf)))
7257     }
7258     #[cfg(not(windows))]
7259     unimplemented!("Unsupported target OS");
7260 }
7261 #[inline]
MsiGetActiveDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> MSIHANDLE7262 pub unsafe fn MsiGetActiveDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> MSIHANDLE {
7263     #[cfg(windows)]
7264     {
7265         #[link(name = "windows")]
7266         extern "system" {
7267             fn MsiGetActiveDatabase(hinstall: MSIHANDLE) -> MSIHANDLE;
7268         }
7269         ::std::mem::transmute(MsiGetActiveDatabase(hinstall.into_param().abi()))
7270     }
7271     #[cfg(not(windows))]
7272     unimplemented!("Unsupported target OS");
7273 }
7274 #[cfg(feature = "Win32_Foundation")]
7275 #[inline]
MsiGetComponentPathA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szcomponent: Param1, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE7276 pub unsafe fn MsiGetComponentPathA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szcomponent: Param1, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE {
7277     #[cfg(windows)]
7278     {
7279         #[link(name = "windows")]
7280         extern "system" {
7281             fn MsiGetComponentPathA(szproduct: super::super::Foundation::PSTR, szcomponent: super::super::Foundation::PSTR, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE;
7282         }
7283         ::std::mem::transmute(MsiGetComponentPathA(szproduct.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchbuf)))
7284     }
7285     #[cfg(not(windows))]
7286     unimplemented!("Unsupported target OS");
7287 }
7288 #[cfg(feature = "Win32_Foundation")]
7289 #[inline]
MsiGetComponentPathExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szcomponentcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE7290 pub unsafe fn MsiGetComponentPathExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szcomponentcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE {
7291     #[cfg(windows)]
7292     {
7293         #[link(name = "windows")]
7294         extern "system" {
7295             fn MsiGetComponentPathExA(szproductcode: super::super::Foundation::PSTR, szcomponentcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE;
7296         }
7297         ::std::mem::transmute(MsiGetComponentPathExA(szproductcode.into_param().abi(), szcomponentcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(lpoutpathbuffer), ::std::mem::transmute(pcchoutpathbuffer)))
7298     }
7299     #[cfg(not(windows))]
7300     unimplemented!("Unsupported target OS");
7301 }
7302 #[cfg(feature = "Win32_Foundation")]
7303 #[inline]
MsiGetComponentPathExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szcomponentcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PWSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE7304 pub unsafe fn MsiGetComponentPathExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szcomponentcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PWSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE {
7305     #[cfg(windows)]
7306     {
7307         #[link(name = "windows")]
7308         extern "system" {
7309             fn MsiGetComponentPathExW(szproductcode: super::super::Foundation::PWSTR, szcomponentcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, lpoutpathbuffer: super::super::Foundation::PWSTR, pcchoutpathbuffer: *mut u32) -> INSTALLSTATE;
7310         }
7311         ::std::mem::transmute(MsiGetComponentPathExW(szproductcode.into_param().abi(), szcomponentcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(lpoutpathbuffer), ::std::mem::transmute(pcchoutpathbuffer)))
7312     }
7313     #[cfg(not(windows))]
7314     unimplemented!("Unsupported target OS");
7315 }
7316 #[cfg(feature = "Win32_Foundation")]
7317 #[inline]
MsiGetComponentPathW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szcomponent: Param1, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE7318 pub unsafe fn MsiGetComponentPathW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szcomponent: Param1, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE {
7319     #[cfg(windows)]
7320     {
7321         #[link(name = "windows")]
7322         extern "system" {
7323             fn MsiGetComponentPathW(szproduct: super::super::Foundation::PWSTR, szcomponent: super::super::Foundation::PWSTR, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE;
7324         }
7325         ::std::mem::transmute(MsiGetComponentPathW(szproduct.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchbuf)))
7326     }
7327     #[cfg(not(windows))]
7328     unimplemented!("Unsupported target OS");
7329 }
7330 #[cfg(feature = "Win32_Foundation")]
7331 #[inline]
MsiGetComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u327332 pub unsafe fn MsiGetComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32 {
7333     #[cfg(windows)]
7334     {
7335         #[link(name = "windows")]
7336         extern "system" {
7337             fn MsiGetComponentStateA(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PSTR, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32;
7338         }
7339         ::std::mem::transmute(MsiGetComponentStateA(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(piinstalled), ::std::mem::transmute(piaction)))
7340     }
7341     #[cfg(not(windows))]
7342     unimplemented!("Unsupported target OS");
7343 }
7344 #[cfg(feature = "Win32_Foundation")]
7345 #[inline]
MsiGetComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u327346 pub unsafe fn MsiGetComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32 {
7347     #[cfg(windows)]
7348     {
7349         #[link(name = "windows")]
7350         extern "system" {
7351             fn MsiGetComponentStateW(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PWSTR, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32;
7352         }
7353         ::std::mem::transmute(MsiGetComponentStateW(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(piinstalled), ::std::mem::transmute(piaction)))
7354     }
7355     #[cfg(not(windows))]
7356     unimplemented!("Unsupported target OS");
7357 }
7358 #[inline]
MsiGetDatabaseState<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0) -> MSIDBSTATE7359 pub unsafe fn MsiGetDatabaseState<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hdatabase: Param0) -> MSIDBSTATE {
7360     #[cfg(windows)]
7361     {
7362         #[link(name = "windows")]
7363         extern "system" {
7364             fn MsiGetDatabaseState(hdatabase: MSIHANDLE) -> MSIDBSTATE;
7365         }
7366         ::std::mem::transmute(MsiGetDatabaseState(hdatabase.into_param().abi()))
7367     }
7368     #[cfg(not(windows))]
7369     unimplemented!("Unsupported target OS");
7370 }
7371 #[cfg(feature = "Win32_Foundation")]
7372 #[inline]
MsiGetFeatureCostA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u327373 pub unsafe fn MsiGetFeatureCostA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u32 {
7374     #[cfg(windows)]
7375     {
7376         #[link(name = "windows")]
7377         extern "system" {
7378             fn MsiGetFeatureCostA(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PSTR, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u32;
7379         }
7380         ::std::mem::transmute(MsiGetFeatureCostA(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(icosttree), ::std::mem::transmute(istate), ::std::mem::transmute(picost)))
7381     }
7382     #[cfg(not(windows))]
7383     unimplemented!("Unsupported target OS");
7384 }
7385 #[cfg(feature = "Win32_Foundation")]
7386 #[inline]
MsiGetFeatureCostW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u327387 pub unsafe fn MsiGetFeatureCostW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u32 {
7388     #[cfg(windows)]
7389     {
7390         #[link(name = "windows")]
7391         extern "system" {
7392             fn MsiGetFeatureCostW(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, icosttree: MSICOSTTREE, istate: INSTALLSTATE, picost: *mut i32) -> u32;
7393         }
7394         ::std::mem::transmute(MsiGetFeatureCostW(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(icosttree), ::std::mem::transmute(istate), ::std::mem::transmute(picost)))
7395     }
7396     #[cfg(not(windows))]
7397     unimplemented!("Unsupported target OS");
7398 }
7399 #[cfg(feature = "Win32_Foundation")]
7400 #[inline]
MsiGetFeatureInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hproduct: Param0, szfeature: Param1, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PSTR, pcchhelpbuf: *mut u32) -> u327401 pub unsafe fn MsiGetFeatureInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hproduct: Param0, szfeature: Param1, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PSTR, pcchhelpbuf: *mut u32) -> u32 {
7402     #[cfg(windows)]
7403     {
7404         #[link(name = "windows")]
7405         extern "system" {
7406             fn MsiGetFeatureInfoA(hproduct: MSIHANDLE, szfeature: super::super::Foundation::PSTR, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PSTR, pcchhelpbuf: *mut u32) -> u32;
7407         }
7408         ::std::mem::transmute(MsiGetFeatureInfoA(hproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(lpattributes), ::std::mem::transmute(lptitlebuf), ::std::mem::transmute(pcchtitlebuf), ::std::mem::transmute(lphelpbuf), ::std::mem::transmute(pcchhelpbuf)))
7409     }
7410     #[cfg(not(windows))]
7411     unimplemented!("Unsupported target OS");
7412 }
7413 #[cfg(feature = "Win32_Foundation")]
7414 #[inline]
MsiGetFeatureInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hproduct: Param0, szfeature: Param1, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PWSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PWSTR, pcchhelpbuf: *mut u32) -> u327415 pub unsafe fn MsiGetFeatureInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hproduct: Param0, szfeature: Param1, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PWSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PWSTR, pcchhelpbuf: *mut u32) -> u32 {
7416     #[cfg(windows)]
7417     {
7418         #[link(name = "windows")]
7419         extern "system" {
7420             fn MsiGetFeatureInfoW(hproduct: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, lpattributes: *mut u32, lptitlebuf: super::super::Foundation::PWSTR, pcchtitlebuf: *mut u32, lphelpbuf: super::super::Foundation::PWSTR, pcchhelpbuf: *mut u32) -> u32;
7421         }
7422         ::std::mem::transmute(MsiGetFeatureInfoW(hproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(lpattributes), ::std::mem::transmute(lptitlebuf), ::std::mem::transmute(pcchtitlebuf), ::std::mem::transmute(lphelpbuf), ::std::mem::transmute(pcchhelpbuf)))
7423     }
7424     #[cfg(not(windows))]
7425     unimplemented!("Unsupported target OS");
7426 }
7427 #[cfg(feature = "Win32_Foundation")]
7428 #[inline]
MsiGetFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u327429 pub unsafe fn MsiGetFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32 {
7430     #[cfg(windows)]
7431     {
7432         #[link(name = "windows")]
7433         extern "system" {
7434             fn MsiGetFeatureStateA(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PSTR, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32;
7435         }
7436         ::std::mem::transmute(MsiGetFeatureStateA(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(piinstalled), ::std::mem::transmute(piaction)))
7437     }
7438     #[cfg(not(windows))]
7439     unimplemented!("Unsupported target OS");
7440 }
7441 #[cfg(feature = "Win32_Foundation")]
7442 #[inline]
MsiGetFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u327443 pub unsafe fn MsiGetFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32 {
7444     #[cfg(windows)]
7445     {
7446         #[link(name = "windows")]
7447         extern "system" {
7448             fn MsiGetFeatureStateW(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, piinstalled: *mut INSTALLSTATE, piaction: *mut INSTALLSTATE) -> u32;
7449         }
7450         ::std::mem::transmute(MsiGetFeatureStateW(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(piinstalled), ::std::mem::transmute(piaction)))
7451     }
7452     #[cfg(not(windows))]
7453     unimplemented!("Unsupported target OS");
7454 }
7455 #[cfg(feature = "Win32_Foundation")]
7456 #[inline]
MsiGetFeatureUsageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, pdwusecount: *mut u32, pwdateused: *mut u16) -> u327457 pub unsafe fn MsiGetFeatureUsageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, pdwusecount: *mut u32, pwdateused: *mut u16) -> u32 {
7458     #[cfg(windows)]
7459     {
7460         #[link(name = "windows")]
7461         extern "system" {
7462             fn MsiGetFeatureUsageA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR, pdwusecount: *mut u32, pwdateused: *mut u16) -> u32;
7463         }
7464         ::std::mem::transmute(MsiGetFeatureUsageA(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(pdwusecount), ::std::mem::transmute(pwdateused)))
7465     }
7466     #[cfg(not(windows))]
7467     unimplemented!("Unsupported target OS");
7468 }
7469 #[cfg(feature = "Win32_Foundation")]
7470 #[inline]
MsiGetFeatureUsageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, pdwusecount: *mut u32, pwdateused: *mut u16) -> u327471 pub unsafe fn MsiGetFeatureUsageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, pdwusecount: *mut u32, pwdateused: *mut u16) -> u32 {
7472     #[cfg(windows)]
7473     {
7474         #[link(name = "windows")]
7475         extern "system" {
7476             fn MsiGetFeatureUsageW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR, pdwusecount: *mut u32, pwdateused: *mut u16) -> u32;
7477         }
7478         ::std::mem::transmute(MsiGetFeatureUsageW(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(pdwusecount), ::std::mem::transmute(pwdateused)))
7479     }
7480     #[cfg(not(windows))]
7481     unimplemented!("Unsupported target OS");
7482 }
7483 #[cfg(feature = "Win32_Foundation")]
7484 #[inline]
MsiGetFeatureValidStatesA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, lpinstallstates: *mut u32) -> u327485 pub unsafe fn MsiGetFeatureValidStatesA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, lpinstallstates: *mut u32) -> u32 {
7486     #[cfg(windows)]
7487     {
7488         #[link(name = "windows")]
7489         extern "system" {
7490             fn MsiGetFeatureValidStatesA(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PSTR, lpinstallstates: *mut u32) -> u32;
7491         }
7492         ::std::mem::transmute(MsiGetFeatureValidStatesA(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(lpinstallstates)))
7493     }
7494     #[cfg(not(windows))]
7495     unimplemented!("Unsupported target OS");
7496 }
7497 #[cfg(feature = "Win32_Foundation")]
7498 #[inline]
MsiGetFeatureValidStatesW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, lpinstallstates: *mut u32) -> u327499 pub unsafe fn MsiGetFeatureValidStatesW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, lpinstallstates: *mut u32) -> u32 {
7500     #[cfg(windows)]
7501     {
7502         #[link(name = "windows")]
7503         extern "system" {
7504             fn MsiGetFeatureValidStatesW(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, lpinstallstates: *mut u32) -> u32;
7505         }
7506         ::std::mem::transmute(MsiGetFeatureValidStatesW(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(lpinstallstates)))
7507     }
7508     #[cfg(not(windows))]
7509     unimplemented!("Unsupported target OS");
7510 }
7511 #[cfg(feature = "Win32_Foundation")]
7512 #[inline]
MsiGetFileHashA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szfilepath: Param0, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u327513 pub unsafe fn MsiGetFileHashA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szfilepath: Param0, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u32 {
7514     #[cfg(windows)]
7515     {
7516         #[link(name = "windows")]
7517         extern "system" {
7518             fn MsiGetFileHashA(szfilepath: super::super::Foundation::PSTR, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u32;
7519         }
7520         ::std::mem::transmute(MsiGetFileHashA(szfilepath.into_param().abi(), ::std::mem::transmute(dwoptions), ::std::mem::transmute(phash)))
7521     }
7522     #[cfg(not(windows))]
7523     unimplemented!("Unsupported target OS");
7524 }
7525 #[cfg(feature = "Win32_Foundation")]
7526 #[inline]
MsiGetFileHashW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szfilepath: Param0, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u327527 pub unsafe fn MsiGetFileHashW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szfilepath: Param0, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u32 {
7528     #[cfg(windows)]
7529     {
7530         #[link(name = "windows")]
7531         extern "system" {
7532             fn MsiGetFileHashW(szfilepath: super::super::Foundation::PWSTR, dwoptions: u32, phash: *mut MSIFILEHASHINFO) -> u32;
7533         }
7534         ::std::mem::transmute(MsiGetFileHashW(szfilepath.into_param().abi(), ::std::mem::transmute(dwoptions), ::std::mem::transmute(phash)))
7535     }
7536     #[cfg(not(windows))]
7537     unimplemented!("Unsupported target OS");
7538 }
7539 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
7540 #[inline]
MsiGetFileSignatureInformationA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szsignedobjectpath: Param0, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::Result<()>7541 pub unsafe fn MsiGetFileSignatureInformationA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szsignedobjectpath: Param0, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::Result<()> {
7542     #[cfg(windows)]
7543     {
7544         #[link(name = "windows")]
7545         extern "system" {
7546             fn MsiGetFileSignatureInformationA(szsignedobjectpath: super::super::Foundation::PSTR, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::HRESULT;
7547         }
7548         MsiGetFileSignatureInformationA(szsignedobjectpath.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppccertcontext), ::std::mem::transmute(pbhashdata), ::std::mem::transmute(pcbhashdata)).ok()
7549     }
7550     #[cfg(not(windows))]
7551     unimplemented!("Unsupported target OS");
7552 }
7553 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
7554 #[inline]
MsiGetFileSignatureInformationW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szsignedobjectpath: Param0, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::Result<()>7555 pub unsafe fn MsiGetFileSignatureInformationW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szsignedobjectpath: Param0, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::Result<()> {
7556     #[cfg(windows)]
7557     {
7558         #[link(name = "windows")]
7559         extern "system" {
7560             fn MsiGetFileSignatureInformationW(szsignedobjectpath: super::super::Foundation::PWSTR, dwflags: u32, ppccertcontext: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, pbhashdata: *mut u8, pcbhashdata: *mut u32) -> ::windows::runtime::HRESULT;
7561         }
7562         MsiGetFileSignatureInformationW(szsignedobjectpath.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppccertcontext), ::std::mem::transmute(pbhashdata), ::std::mem::transmute(pcbhashdata)).ok()
7563     }
7564     #[cfg(not(windows))]
7565     unimplemented!("Unsupported target OS");
7566 }
7567 #[cfg(feature = "Win32_Foundation")]
7568 #[inline]
MsiGetFileVersionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szfilepath: Param0, lpversionbuf: super::super::Foundation::PSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PSTR, pcchlangbuf: *mut u32) -> u327569 pub unsafe fn MsiGetFileVersionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szfilepath: Param0, lpversionbuf: super::super::Foundation::PSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PSTR, pcchlangbuf: *mut u32) -> u32 {
7570     #[cfg(windows)]
7571     {
7572         #[link(name = "windows")]
7573         extern "system" {
7574             fn MsiGetFileVersionA(szfilepath: super::super::Foundation::PSTR, lpversionbuf: super::super::Foundation::PSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PSTR, pcchlangbuf: *mut u32) -> u32;
7575         }
7576         ::std::mem::transmute(MsiGetFileVersionA(szfilepath.into_param().abi(), ::std::mem::transmute(lpversionbuf), ::std::mem::transmute(pcchversionbuf), ::std::mem::transmute(lplangbuf), ::std::mem::transmute(pcchlangbuf)))
7577     }
7578     #[cfg(not(windows))]
7579     unimplemented!("Unsupported target OS");
7580 }
7581 #[cfg(feature = "Win32_Foundation")]
7582 #[inline]
MsiGetFileVersionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szfilepath: Param0, lpversionbuf: super::super::Foundation::PWSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PWSTR, pcchlangbuf: *mut u32) -> u327583 pub unsafe fn MsiGetFileVersionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szfilepath: Param0, lpversionbuf: super::super::Foundation::PWSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PWSTR, pcchlangbuf: *mut u32) -> u32 {
7584     #[cfg(windows)]
7585     {
7586         #[link(name = "windows")]
7587         extern "system" {
7588             fn MsiGetFileVersionW(szfilepath: super::super::Foundation::PWSTR, lpversionbuf: super::super::Foundation::PWSTR, pcchversionbuf: *mut u32, lplangbuf: super::super::Foundation::PWSTR, pcchlangbuf: *mut u32) -> u32;
7589         }
7590         ::std::mem::transmute(MsiGetFileVersionW(szfilepath.into_param().abi(), ::std::mem::transmute(lpversionbuf), ::std::mem::transmute(pcchversionbuf), ::std::mem::transmute(lplangbuf), ::std::mem::transmute(pcchlangbuf)))
7591     }
7592     #[cfg(not(windows))]
7593     unimplemented!("Unsupported target OS");
7594 }
7595 #[inline]
MsiGetLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> u167596 pub unsafe fn MsiGetLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> u16 {
7597     #[cfg(windows)]
7598     {
7599         #[link(name = "windows")]
7600         extern "system" {
7601             fn MsiGetLanguage(hinstall: MSIHANDLE) -> u16;
7602         }
7603         ::std::mem::transmute(MsiGetLanguage(hinstall.into_param().abi()))
7604     }
7605     #[cfg(not(windows))]
7606     unimplemented!("Unsupported target OS");
7607 }
7608 #[inline]
MsiGetLastErrorRecord() -> MSIHANDLE7609 pub unsafe fn MsiGetLastErrorRecord() -> MSIHANDLE {
7610     #[cfg(windows)]
7611     {
7612         #[link(name = "windows")]
7613         extern "system" {
7614             fn MsiGetLastErrorRecord() -> MSIHANDLE;
7615         }
7616         ::std::mem::transmute(MsiGetLastErrorRecord())
7617     }
7618     #[cfg(not(windows))]
7619     unimplemented!("Unsupported target OS");
7620 }
7621 #[cfg(feature = "Win32_Foundation")]
7622 #[inline]
MsiGetMode<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, erunmode: MSIRUNMODE) -> super::super::Foundation::BOOL7623 pub unsafe fn MsiGetMode<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, erunmode: MSIRUNMODE) -> super::super::Foundation::BOOL {
7624     #[cfg(windows)]
7625     {
7626         #[link(name = "windows")]
7627         extern "system" {
7628             fn MsiGetMode(hinstall: MSIHANDLE, erunmode: MSIRUNMODE) -> super::super::Foundation::BOOL;
7629         }
7630         ::std::mem::transmute(MsiGetMode(hinstall.into_param().abi(), ::std::mem::transmute(erunmode)))
7631     }
7632     #[cfg(not(windows))]
7633     unimplemented!("Unsupported target OS");
7634 }
7635 #[cfg(feature = "Win32_Foundation")]
7636 #[inline]
MsiGetPatchFileListA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szpatchpackages: Param1, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u327637 pub unsafe fn MsiGetPatchFileListA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szpatchpackages: Param1, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u32 {
7638     #[cfg(windows)]
7639     {
7640         #[link(name = "windows")]
7641         extern "system" {
7642             fn MsiGetPatchFileListA(szproductcode: super::super::Foundation::PSTR, szpatchpackages: super::super::Foundation::PSTR, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u32;
7643         }
7644         ::std::mem::transmute(MsiGetPatchFileListA(szproductcode.into_param().abi(), szpatchpackages.into_param().abi(), ::std::mem::transmute(pcfiles), ::std::mem::transmute(pphfilerecords)))
7645     }
7646     #[cfg(not(windows))]
7647     unimplemented!("Unsupported target OS");
7648 }
7649 #[cfg(feature = "Win32_Foundation")]
7650 #[inline]
MsiGetPatchFileListW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szpatchpackages: Param1, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u327651 pub unsafe fn MsiGetPatchFileListW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szpatchpackages: Param1, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u32 {
7652     #[cfg(windows)]
7653     {
7654         #[link(name = "windows")]
7655         extern "system" {
7656             fn MsiGetPatchFileListW(szproductcode: super::super::Foundation::PWSTR, szpatchpackages: super::super::Foundation::PWSTR, pcfiles: *mut u32, pphfilerecords: *mut *mut MSIHANDLE) -> u32;
7657         }
7658         ::std::mem::transmute(MsiGetPatchFileListW(szproductcode.into_param().abi(), szpatchpackages.into_param().abi(), ::std::mem::transmute(pcfiles), ::std::mem::transmute(pphfilerecords)))
7659     }
7660     #[cfg(not(windows))]
7661     unimplemented!("Unsupported target OS");
7662 }
7663 #[cfg(feature = "Win32_Foundation")]
7664 #[inline]
MsiGetPatchInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatch: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u327665 pub unsafe fn MsiGetPatchInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatch: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
7666     #[cfg(windows)]
7667     {
7668         #[link(name = "windows")]
7669         extern "system" {
7670             fn MsiGetPatchInfoA(szpatch: super::super::Foundation::PSTR, szattribute: super::super::Foundation::PSTR, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
7671         }
7672         ::std::mem::transmute(MsiGetPatchInfoA(szpatch.into_param().abi(), szattribute.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7673     }
7674     #[cfg(not(windows))]
7675     unimplemented!("Unsupported target OS");
7676 }
7677 #[cfg(feature = "Win32_Foundation")]
7678 #[inline]
MsiGetPatchInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( szpatchcode: Param0, szproductcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, szproperty: Param4, lpvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32, ) -> u327679 pub unsafe fn MsiGetPatchInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
7680     szpatchcode: Param0,
7681     szproductcode: Param1,
7682     szusersid: Param2,
7683     dwcontext: MSIINSTALLCONTEXT,
7684     szproperty: Param4,
7685     lpvalue: super::super::Foundation::PSTR,
7686     pcchvalue: *mut u32,
7687 ) -> u32 {
7688     #[cfg(windows)]
7689     {
7690         #[link(name = "windows")]
7691         extern "system" {
7692             fn MsiGetPatchInfoExA(szpatchcode: super::super::Foundation::PSTR, szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, szproperty: super::super::Foundation::PSTR, lpvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u32;
7693         }
7694         ::std::mem::transmute(MsiGetPatchInfoExA(szpatchcode.into_param().abi(), szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szproperty.into_param().abi(), ::std::mem::transmute(lpvalue), ::std::mem::transmute(pcchvalue)))
7695     }
7696     #[cfg(not(windows))]
7697     unimplemented!("Unsupported target OS");
7698 }
7699 #[cfg(feature = "Win32_Foundation")]
7700 #[inline]
MsiGetPatchInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( szpatchcode: Param0, szproductcode: Param1, szusersid: Param2, dwcontext: MSIINSTALLCONTEXT, szproperty: Param4, lpvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32, ) -> u327701 pub unsafe fn MsiGetPatchInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
7702     szpatchcode: Param0,
7703     szproductcode: Param1,
7704     szusersid: Param2,
7705     dwcontext: MSIINSTALLCONTEXT,
7706     szproperty: Param4,
7707     lpvalue: super::super::Foundation::PWSTR,
7708     pcchvalue: *mut u32,
7709 ) -> u32 {
7710     #[cfg(windows)]
7711     {
7712         #[link(name = "windows")]
7713         extern "system" {
7714             fn MsiGetPatchInfoExW(szpatchcode: super::super::Foundation::PWSTR, szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, szproperty: super::super::Foundation::PWSTR, lpvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u32;
7715         }
7716         ::std::mem::transmute(MsiGetPatchInfoExW(szpatchcode.into_param().abi(), szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szproperty.into_param().abi(), ::std::mem::transmute(lpvalue), ::std::mem::transmute(pcchvalue)))
7717     }
7718     #[cfg(not(windows))]
7719     unimplemented!("Unsupported target OS");
7720 }
7721 #[cfg(feature = "Win32_Foundation")]
7722 #[inline]
MsiGetPatchInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatch: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u327723 pub unsafe fn MsiGetPatchInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatch: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
7724     #[cfg(windows)]
7725     {
7726         #[link(name = "windows")]
7727         extern "system" {
7728             fn MsiGetPatchInfoW(szpatch: super::super::Foundation::PWSTR, szattribute: super::super::Foundation::PWSTR, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
7729         }
7730         ::std::mem::transmute(MsiGetPatchInfoW(szpatch.into_param().abi(), szattribute.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7731     }
7732     #[cfg(not(windows))]
7733     unimplemented!("Unsupported target OS");
7734 }
7735 #[cfg(feature = "Win32_Foundation")]
7736 #[inline]
MsiGetProductCodeA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, lpbuf39: super::super::Foundation::PSTR) -> u327737 pub unsafe fn MsiGetProductCodeA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, lpbuf39: super::super::Foundation::PSTR) -> u32 {
7738     #[cfg(windows)]
7739     {
7740         #[link(name = "windows")]
7741         extern "system" {
7742             fn MsiGetProductCodeA(szcomponent: super::super::Foundation::PSTR, lpbuf39: super::super::Foundation::PSTR) -> u32;
7743         }
7744         ::std::mem::transmute(MsiGetProductCodeA(szcomponent.into_param().abi(), ::std::mem::transmute(lpbuf39)))
7745     }
7746     #[cfg(not(windows))]
7747     unimplemented!("Unsupported target OS");
7748 }
7749 #[cfg(feature = "Win32_Foundation")]
7750 #[inline]
MsiGetProductCodeW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, lpbuf39: super::super::Foundation::PWSTR) -> u327751 pub unsafe fn MsiGetProductCodeW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, lpbuf39: super::super::Foundation::PWSTR) -> u32 {
7752     #[cfg(windows)]
7753     {
7754         #[link(name = "windows")]
7755         extern "system" {
7756             fn MsiGetProductCodeW(szcomponent: super::super::Foundation::PWSTR, lpbuf39: super::super::Foundation::PWSTR) -> u32;
7757         }
7758         ::std::mem::transmute(MsiGetProductCodeW(szcomponent.into_param().abi(), ::std::mem::transmute(lpbuf39)))
7759     }
7760     #[cfg(not(windows))]
7761     unimplemented!("Unsupported target OS");
7762 }
7763 #[cfg(feature = "Win32_Foundation")]
7764 #[inline]
MsiGetProductInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u327765 pub unsafe fn MsiGetProductInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
7766     #[cfg(windows)]
7767     {
7768         #[link(name = "windows")]
7769         extern "system" {
7770             fn MsiGetProductInfoA(szproduct: super::super::Foundation::PSTR, szattribute: super::super::Foundation::PSTR, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
7771         }
7772         ::std::mem::transmute(MsiGetProductInfoA(szproduct.into_param().abi(), szattribute.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7773     }
7774     #[cfg(not(windows))]
7775     unimplemented!("Unsupported target OS");
7776 }
7777 #[cfg(feature = "Win32_Foundation")]
7778 #[inline]
MsiGetProductInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szproperty: Param3, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u327779 pub unsafe fn MsiGetProductInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szproperty: Param3, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u32 {
7780     #[cfg(windows)]
7781     {
7782         #[link(name = "windows")]
7783         extern "system" {
7784             fn MsiGetProductInfoExA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, szproperty: super::super::Foundation::PSTR, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u32;
7785         }
7786         ::std::mem::transmute(MsiGetProductInfoExA(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szproperty.into_param().abi(), ::std::mem::transmute(szvalue), ::std::mem::transmute(pcchvalue)))
7787     }
7788     #[cfg(not(windows))]
7789     unimplemented!("Unsupported target OS");
7790 }
7791 #[cfg(feature = "Win32_Foundation")]
7792 #[inline]
MsiGetProductInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szproperty: Param3, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u327793 pub unsafe fn MsiGetProductInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szproperty: Param3, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u32 {
7794     #[cfg(windows)]
7795     {
7796         #[link(name = "windows")]
7797         extern "system" {
7798             fn MsiGetProductInfoExW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, szproperty: super::super::Foundation::PWSTR, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u32;
7799         }
7800         ::std::mem::transmute(MsiGetProductInfoExW(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szproperty.into_param().abi(), ::std::mem::transmute(szvalue), ::std::mem::transmute(pcchvalue)))
7801     }
7802     #[cfg(not(windows))]
7803     unimplemented!("Unsupported target OS");
7804 }
7805 #[cfg(feature = "Win32_Foundation")]
7806 #[inline]
MsiGetProductInfoFromScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szscriptfile: Param0, lpproductbuf39: super::super::Foundation::PSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PSTR, pcchpackagebuf: *mut u32) -> u327807 pub unsafe fn MsiGetProductInfoFromScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szscriptfile: Param0, lpproductbuf39: super::super::Foundation::PSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PSTR, pcchpackagebuf: *mut u32) -> u32 {
7808     #[cfg(windows)]
7809     {
7810         #[link(name = "windows")]
7811         extern "system" {
7812             fn MsiGetProductInfoFromScriptA(szscriptfile: super::super::Foundation::PSTR, lpproductbuf39: super::super::Foundation::PSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PSTR, pcchpackagebuf: *mut u32) -> u32;
7813         }
7814         ::std::mem::transmute(MsiGetProductInfoFromScriptA(
7815             szscriptfile.into_param().abi(),
7816             ::std::mem::transmute(lpproductbuf39),
7817             ::std::mem::transmute(plgidlanguage),
7818             ::std::mem::transmute(pdwversion),
7819             ::std::mem::transmute(lpnamebuf),
7820             ::std::mem::transmute(pcchnamebuf),
7821             ::std::mem::transmute(lppackagebuf),
7822             ::std::mem::transmute(pcchpackagebuf),
7823         ))
7824     }
7825     #[cfg(not(windows))]
7826     unimplemented!("Unsupported target OS");
7827 }
7828 #[cfg(feature = "Win32_Foundation")]
7829 #[inline]
MsiGetProductInfoFromScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szscriptfile: Param0, lpproductbuf39: super::super::Foundation::PWSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PWSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PWSTR, pcchpackagebuf: *mut u32) -> u327830 pub unsafe fn MsiGetProductInfoFromScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szscriptfile: Param0, lpproductbuf39: super::super::Foundation::PWSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PWSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PWSTR, pcchpackagebuf: *mut u32) -> u32 {
7831     #[cfg(windows)]
7832     {
7833         #[link(name = "windows")]
7834         extern "system" {
7835             fn MsiGetProductInfoFromScriptW(szscriptfile: super::super::Foundation::PWSTR, lpproductbuf39: super::super::Foundation::PWSTR, plgidlanguage: *mut u16, pdwversion: *mut u32, lpnamebuf: super::super::Foundation::PWSTR, pcchnamebuf: *mut u32, lppackagebuf: super::super::Foundation::PWSTR, pcchpackagebuf: *mut u32) -> u32;
7836         }
7837         ::std::mem::transmute(MsiGetProductInfoFromScriptW(
7838             szscriptfile.into_param().abi(),
7839             ::std::mem::transmute(lpproductbuf39),
7840             ::std::mem::transmute(plgidlanguage),
7841             ::std::mem::transmute(pdwversion),
7842             ::std::mem::transmute(lpnamebuf),
7843             ::std::mem::transmute(pcchnamebuf),
7844             ::std::mem::transmute(lppackagebuf),
7845             ::std::mem::transmute(pcchpackagebuf),
7846         ))
7847     }
7848     #[cfg(not(windows))]
7849     unimplemented!("Unsupported target OS");
7850 }
7851 #[cfg(feature = "Win32_Foundation")]
7852 #[inline]
MsiGetProductInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u327853 pub unsafe fn MsiGetProductInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szattribute: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
7854     #[cfg(windows)]
7855     {
7856         #[link(name = "windows")]
7857         extern "system" {
7858             fn MsiGetProductInfoW(szproduct: super::super::Foundation::PWSTR, szattribute: super::super::Foundation::PWSTR, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
7859         }
7860         ::std::mem::transmute(MsiGetProductInfoW(szproduct.into_param().abi(), szattribute.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7861     }
7862     #[cfg(not(windows))]
7863     unimplemented!("Unsupported target OS");
7864 }
7865 #[cfg(feature = "Win32_Foundation")]
7866 #[inline]
MsiGetProductPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hproduct: Param0, szproperty: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u327867 pub unsafe fn MsiGetProductPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hproduct: Param0, szproperty: Param1, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
7868     #[cfg(windows)]
7869     {
7870         #[link(name = "windows")]
7871         extern "system" {
7872             fn MsiGetProductPropertyA(hproduct: MSIHANDLE, szproperty: super::super::Foundation::PSTR, lpvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
7873         }
7874         ::std::mem::transmute(MsiGetProductPropertyA(hproduct.into_param().abi(), szproperty.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7875     }
7876     #[cfg(not(windows))]
7877     unimplemented!("Unsupported target OS");
7878 }
7879 #[cfg(feature = "Win32_Foundation")]
7880 #[inline]
MsiGetProductPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hproduct: Param0, szproperty: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u327881 pub unsafe fn MsiGetProductPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hproduct: Param0, szproperty: Param1, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
7882     #[cfg(windows)]
7883     {
7884         #[link(name = "windows")]
7885         extern "system" {
7886             fn MsiGetProductPropertyW(hproduct: MSIHANDLE, szproperty: super::super::Foundation::PWSTR, lpvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
7887         }
7888         ::std::mem::transmute(MsiGetProductPropertyW(hproduct.into_param().abi(), szproperty.into_param().abi(), ::std::mem::transmute(lpvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7889     }
7890     #[cfg(not(windows))]
7891     unimplemented!("Unsupported target OS");
7892 }
7893 #[cfg(feature = "Win32_Foundation")]
7894 #[inline]
MsiGetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szname: Param1, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u327895 pub unsafe fn MsiGetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szname: Param1, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
7896     #[cfg(windows)]
7897     {
7898         #[link(name = "windows")]
7899         extern "system" {
7900             fn MsiGetPropertyA(hinstall: MSIHANDLE, szname: super::super::Foundation::PSTR, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
7901         }
7902         ::std::mem::transmute(MsiGetPropertyA(hinstall.into_param().abi(), szname.into_param().abi(), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7903     }
7904     #[cfg(not(windows))]
7905     unimplemented!("Unsupported target OS");
7906 }
7907 #[cfg(feature = "Win32_Foundation")]
7908 #[inline]
MsiGetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szname: Param1, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u327909 pub unsafe fn MsiGetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szname: Param1, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
7910     #[cfg(windows)]
7911     {
7912         #[link(name = "windows")]
7913         extern "system" {
7914             fn MsiGetPropertyW(hinstall: MSIHANDLE, szname: super::super::Foundation::PWSTR, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
7915         }
7916         ::std::mem::transmute(MsiGetPropertyW(hinstall.into_param().abi(), szname.into_param().abi(), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
7917     }
7918     #[cfg(not(windows))]
7919     unimplemented!("Unsupported target OS");
7920 }
7921 #[cfg(feature = "Win32_Foundation")]
7922 #[inline]
MsiGetShortcutTargetA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szshortcutpath: Param0, szproductcode: super::super::Foundation::PSTR, szfeatureid: super::super::Foundation::PSTR, szcomponentcode: super::super::Foundation::PSTR) -> u327923 pub unsafe fn MsiGetShortcutTargetA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szshortcutpath: Param0, szproductcode: super::super::Foundation::PSTR, szfeatureid: super::super::Foundation::PSTR, szcomponentcode: super::super::Foundation::PSTR) -> u32 {
7924     #[cfg(windows)]
7925     {
7926         #[link(name = "windows")]
7927         extern "system" {
7928             fn MsiGetShortcutTargetA(szshortcutpath: super::super::Foundation::PSTR, szproductcode: super::super::Foundation::PSTR, szfeatureid: super::super::Foundation::PSTR, szcomponentcode: super::super::Foundation::PSTR) -> u32;
7929         }
7930         ::std::mem::transmute(MsiGetShortcutTargetA(szshortcutpath.into_param().abi(), ::std::mem::transmute(szproductcode), ::std::mem::transmute(szfeatureid), ::std::mem::transmute(szcomponentcode)))
7931     }
7932     #[cfg(not(windows))]
7933     unimplemented!("Unsupported target OS");
7934 }
7935 #[cfg(feature = "Win32_Foundation")]
7936 #[inline]
MsiGetShortcutTargetW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szshortcutpath: Param0, szproductcode: super::super::Foundation::PWSTR, szfeatureid: super::super::Foundation::PWSTR, szcomponentcode: super::super::Foundation::PWSTR) -> u327937 pub unsafe fn MsiGetShortcutTargetW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szshortcutpath: Param0, szproductcode: super::super::Foundation::PWSTR, szfeatureid: super::super::Foundation::PWSTR, szcomponentcode: super::super::Foundation::PWSTR) -> u32 {
7938     #[cfg(windows)]
7939     {
7940         #[link(name = "windows")]
7941         extern "system" {
7942             fn MsiGetShortcutTargetW(szshortcutpath: super::super::Foundation::PWSTR, szproductcode: super::super::Foundation::PWSTR, szfeatureid: super::super::Foundation::PWSTR, szcomponentcode: super::super::Foundation::PWSTR) -> u32;
7943         }
7944         ::std::mem::transmute(MsiGetShortcutTargetW(szshortcutpath.into_param().abi(), ::std::mem::transmute(szproductcode), ::std::mem::transmute(szfeatureid), ::std::mem::transmute(szcomponentcode)))
7945     }
7946     #[cfg(not(windows))]
7947     unimplemented!("Unsupported target OS");
7948 }
7949 #[cfg(feature = "Win32_Foundation")]
7950 #[inline]
MsiGetSourcePathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u327951 pub unsafe fn MsiGetSourcePathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
7952     #[cfg(windows)]
7953     {
7954         #[link(name = "windows")]
7955         extern "system" {
7956             fn MsiGetSourcePathA(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PSTR, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
7957         }
7958         ::std::mem::transmute(MsiGetSourcePathA(hinstall.into_param().abi(), szfolder.into_param().abi(), ::std::mem::transmute(szpathbuf), ::std::mem::transmute(pcchpathbuf)))
7959     }
7960     #[cfg(not(windows))]
7961     unimplemented!("Unsupported target OS");
7962 }
7963 #[cfg(feature = "Win32_Foundation")]
7964 #[inline]
MsiGetSourcePathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u327965 pub unsafe fn MsiGetSourcePathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
7966     #[cfg(windows)]
7967     {
7968         #[link(name = "windows")]
7969         extern "system" {
7970             fn MsiGetSourcePathW(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PWSTR, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
7971         }
7972         ::std::mem::transmute(MsiGetSourcePathW(hinstall.into_param().abi(), szfolder.into_param().abi(), ::std::mem::transmute(szpathbuf), ::std::mem::transmute(pcchpathbuf)))
7973     }
7974     #[cfg(not(windows))]
7975     unimplemented!("Unsupported target OS");
7976 }
7977 #[cfg(feature = "Win32_Foundation")]
7978 #[inline]
MsiGetSummaryInformationA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szdatabasepath: Param1, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u327979 pub unsafe fn MsiGetSummaryInformationA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hdatabase: Param0, szdatabasepath: Param1, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u32 {
7980     #[cfg(windows)]
7981     {
7982         #[link(name = "windows")]
7983         extern "system" {
7984             fn MsiGetSummaryInformationA(hdatabase: MSIHANDLE, szdatabasepath: super::super::Foundation::PSTR, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u32;
7985         }
7986         ::std::mem::transmute(MsiGetSummaryInformationA(hdatabase.into_param().abi(), szdatabasepath.into_param().abi(), ::std::mem::transmute(uiupdatecount), ::std::mem::transmute(phsummaryinfo)))
7987     }
7988     #[cfg(not(windows))]
7989     unimplemented!("Unsupported target OS");
7990 }
7991 #[cfg(feature = "Win32_Foundation")]
7992 #[inline]
MsiGetSummaryInformationW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szdatabasepath: Param1, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u327993 pub unsafe fn MsiGetSummaryInformationW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hdatabase: Param0, szdatabasepath: Param1, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u32 {
7994     #[cfg(windows)]
7995     {
7996         #[link(name = "windows")]
7997         extern "system" {
7998             fn MsiGetSummaryInformationW(hdatabase: MSIHANDLE, szdatabasepath: super::super::Foundation::PWSTR, uiupdatecount: u32, phsummaryinfo: *mut MSIHANDLE) -> u32;
7999         }
8000         ::std::mem::transmute(MsiGetSummaryInformationW(hdatabase.into_param().abi(), szdatabasepath.into_param().abi(), ::std::mem::transmute(uiupdatecount), ::std::mem::transmute(phsummaryinfo)))
8001     }
8002     #[cfg(not(windows))]
8003     unimplemented!("Unsupported target OS");
8004 }
8005 #[cfg(feature = "Win32_Foundation")]
8006 #[inline]
MsiGetTargetPathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u328007 pub unsafe fn MsiGetTargetPathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
8008     #[cfg(windows)]
8009     {
8010         #[link(name = "windows")]
8011         extern "system" {
8012             fn MsiGetTargetPathA(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PSTR, szpathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
8013         }
8014         ::std::mem::transmute(MsiGetTargetPathA(hinstall.into_param().abi(), szfolder.into_param().abi(), ::std::mem::transmute(szpathbuf), ::std::mem::transmute(pcchpathbuf)))
8015     }
8016     #[cfg(not(windows))]
8017     unimplemented!("Unsupported target OS");
8018 }
8019 #[cfg(feature = "Win32_Foundation")]
8020 #[inline]
MsiGetTargetPathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u328021 pub unsafe fn MsiGetTargetPathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
8022     #[cfg(windows)]
8023     {
8024         #[link(name = "windows")]
8025         extern "system" {
8026             fn MsiGetTargetPathW(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PWSTR, szpathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
8027         }
8028         ::std::mem::transmute(MsiGetTargetPathW(hinstall.into_param().abi(), szfolder.into_param().abi(), ::std::mem::transmute(szpathbuf), ::std::mem::transmute(pcchpathbuf)))
8029     }
8030     #[cfg(not(windows))]
8031     unimplemented!("Unsupported target OS");
8032 }
8033 #[cfg(feature = "Win32_Foundation")]
8034 #[inline]
MsiGetUserInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, lpusernamebuf: super::super::Foundation::PSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE8035 pub unsafe fn MsiGetUserInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, lpusernamebuf: super::super::Foundation::PSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE {
8036     #[cfg(windows)]
8037     {
8038         #[link(name = "windows")]
8039         extern "system" {
8040             fn MsiGetUserInfoA(szproduct: super::super::Foundation::PSTR, lpusernamebuf: super::super::Foundation::PSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE;
8041         }
8042         ::std::mem::transmute(MsiGetUserInfoA(szproduct.into_param().abi(), ::std::mem::transmute(lpusernamebuf), ::std::mem::transmute(pcchusernamebuf), ::std::mem::transmute(lporgnamebuf), ::std::mem::transmute(pcchorgnamebuf), ::std::mem::transmute(lpserialbuf), ::std::mem::transmute(pcchserialbuf)))
8043     }
8044     #[cfg(not(windows))]
8045     unimplemented!("Unsupported target OS");
8046 }
8047 #[cfg(feature = "Win32_Foundation")]
8048 #[inline]
MsiGetUserInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, lpusernamebuf: super::super::Foundation::PWSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PWSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PWSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE8049 pub unsafe fn MsiGetUserInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, lpusernamebuf: super::super::Foundation::PWSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PWSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PWSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE {
8050     #[cfg(windows)]
8051     {
8052         #[link(name = "windows")]
8053         extern "system" {
8054             fn MsiGetUserInfoW(szproduct: super::super::Foundation::PWSTR, lpusernamebuf: super::super::Foundation::PWSTR, pcchusernamebuf: *mut u32, lporgnamebuf: super::super::Foundation::PWSTR, pcchorgnamebuf: *mut u32, lpserialbuf: super::super::Foundation::PWSTR, pcchserialbuf: *mut u32) -> USERINFOSTATE;
8055         }
8056         ::std::mem::transmute(MsiGetUserInfoW(szproduct.into_param().abi(), ::std::mem::transmute(lpusernamebuf), ::std::mem::transmute(pcchusernamebuf), ::std::mem::transmute(lporgnamebuf), ::std::mem::transmute(pcchorgnamebuf), ::std::mem::transmute(lpserialbuf), ::std::mem::transmute(pcchserialbuf)))
8057     }
8058     #[cfg(not(windows))]
8059     unimplemented!("Unsupported target OS");
8060 }
8061 #[cfg(feature = "Win32_Foundation")]
8062 #[inline]
MsiInstallMissingComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szcomponent: Param1, einstallstate: INSTALLSTATE) -> u328063 pub unsafe fn MsiInstallMissingComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szcomponent: Param1, einstallstate: INSTALLSTATE) -> u32 {
8064     #[cfg(windows)]
8065     {
8066         #[link(name = "windows")]
8067         extern "system" {
8068             fn MsiInstallMissingComponentA(szproduct: super::super::Foundation::PSTR, szcomponent: super::super::Foundation::PSTR, einstallstate: INSTALLSTATE) -> u32;
8069         }
8070         ::std::mem::transmute(MsiInstallMissingComponentA(szproduct.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(einstallstate)))
8071     }
8072     #[cfg(not(windows))]
8073     unimplemented!("Unsupported target OS");
8074 }
8075 #[cfg(feature = "Win32_Foundation")]
8076 #[inline]
MsiInstallMissingComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szcomponent: Param1, einstallstate: INSTALLSTATE) -> u328077 pub unsafe fn MsiInstallMissingComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szcomponent: Param1, einstallstate: INSTALLSTATE) -> u32 {
8078     #[cfg(windows)]
8079     {
8080         #[link(name = "windows")]
8081         extern "system" {
8082             fn MsiInstallMissingComponentW(szproduct: super::super::Foundation::PWSTR, szcomponent: super::super::Foundation::PWSTR, einstallstate: INSTALLSTATE) -> u32;
8083         }
8084         ::std::mem::transmute(MsiInstallMissingComponentW(szproduct.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(einstallstate)))
8085     }
8086     #[cfg(not(windows))]
8087     unimplemented!("Unsupported target OS");
8088 }
8089 #[cfg(feature = "Win32_Foundation")]
8090 #[inline]
MsiInstallMissingFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfile: Param1) -> u328091 pub unsafe fn MsiInstallMissingFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfile: Param1) -> u32 {
8092     #[cfg(windows)]
8093     {
8094         #[link(name = "windows")]
8095         extern "system" {
8096             fn MsiInstallMissingFileA(szproduct: super::super::Foundation::PSTR, szfile: super::super::Foundation::PSTR) -> u32;
8097         }
8098         ::std::mem::transmute(MsiInstallMissingFileA(szproduct.into_param().abi(), szfile.into_param().abi()))
8099     }
8100     #[cfg(not(windows))]
8101     unimplemented!("Unsupported target OS");
8102 }
8103 #[cfg(feature = "Win32_Foundation")]
8104 #[inline]
MsiInstallMissingFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfile: Param1) -> u328105 pub unsafe fn MsiInstallMissingFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfile: Param1) -> u32 {
8106     #[cfg(windows)]
8107     {
8108         #[link(name = "windows")]
8109         extern "system" {
8110             fn MsiInstallMissingFileW(szproduct: super::super::Foundation::PWSTR, szfile: super::super::Foundation::PWSTR) -> u32;
8111         }
8112         ::std::mem::transmute(MsiInstallMissingFileW(szproduct.into_param().abi(), szfile.into_param().abi()))
8113     }
8114     #[cfg(not(windows))]
8115     unimplemented!("Unsupported target OS");
8116 }
8117 #[cfg(feature = "Win32_Foundation")]
8118 #[inline]
MsiInstallProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szcommandline: Param1) -> u328119 pub unsafe fn MsiInstallProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, szcommandline: Param1) -> u32 {
8120     #[cfg(windows)]
8121     {
8122         #[link(name = "windows")]
8123         extern "system" {
8124             fn MsiInstallProductA(szpackagepath: super::super::Foundation::PSTR, szcommandline: super::super::Foundation::PSTR) -> u32;
8125         }
8126         ::std::mem::transmute(MsiInstallProductA(szpackagepath.into_param().abi(), szcommandline.into_param().abi()))
8127     }
8128     #[cfg(not(windows))]
8129     unimplemented!("Unsupported target OS");
8130 }
8131 #[cfg(feature = "Win32_Foundation")]
8132 #[inline]
MsiInstallProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szcommandline: Param1) -> u328133 pub unsafe fn MsiInstallProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, szcommandline: Param1) -> u32 {
8134     #[cfg(windows)]
8135     {
8136         #[link(name = "windows")]
8137         extern "system" {
8138             fn MsiInstallProductW(szpackagepath: super::super::Foundation::PWSTR, szcommandline: super::super::Foundation::PWSTR) -> u32;
8139         }
8140         ::std::mem::transmute(MsiInstallProductW(szpackagepath.into_param().abi(), szcommandline.into_param().abi()))
8141     }
8142     #[cfg(not(windows))]
8143     unimplemented!("Unsupported target OS");
8144 }
8145 #[cfg(feature = "Win32_Foundation")]
8146 #[inline]
MsiIsProductElevatedA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, pfelevated: *mut super::super::Foundation::BOOL) -> u328147 pub unsafe fn MsiIsProductElevatedA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, pfelevated: *mut super::super::Foundation::BOOL) -> u32 {
8148     #[cfg(windows)]
8149     {
8150         #[link(name = "windows")]
8151         extern "system" {
8152             fn MsiIsProductElevatedA(szproduct: super::super::Foundation::PSTR, pfelevated: *mut super::super::Foundation::BOOL) -> u32;
8153         }
8154         ::std::mem::transmute(MsiIsProductElevatedA(szproduct.into_param().abi(), ::std::mem::transmute(pfelevated)))
8155     }
8156     #[cfg(not(windows))]
8157     unimplemented!("Unsupported target OS");
8158 }
8159 #[cfg(feature = "Win32_Foundation")]
8160 #[inline]
MsiIsProductElevatedW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, pfelevated: *mut super::super::Foundation::BOOL) -> u328161 pub unsafe fn MsiIsProductElevatedW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, pfelevated: *mut super::super::Foundation::BOOL) -> u32 {
8162     #[cfg(windows)]
8163     {
8164         #[link(name = "windows")]
8165         extern "system" {
8166             fn MsiIsProductElevatedW(szproduct: super::super::Foundation::PWSTR, pfelevated: *mut super::super::Foundation::BOOL) -> u32;
8167         }
8168         ::std::mem::transmute(MsiIsProductElevatedW(szproduct.into_param().abi(), ::std::mem::transmute(pfelevated)))
8169     }
8170     #[cfg(not(windows))]
8171     unimplemented!("Unsupported target OS");
8172 }
8173 #[cfg(feature = "Win32_Foundation")]
8174 #[inline]
MsiJoinTransaction<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(htransactionhandle: Param0, dwtransactionattributes: u32, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u328175 pub unsafe fn MsiJoinTransaction<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(htransactionhandle: Param0, dwtransactionattributes: u32, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32 {
8176     #[cfg(windows)]
8177     {
8178         #[link(name = "windows")]
8179         extern "system" {
8180             fn MsiJoinTransaction(htransactionhandle: MSIHANDLE, dwtransactionattributes: u32, phchangeofownerevent: *mut super::super::Foundation::HANDLE) -> u32;
8181         }
8182         ::std::mem::transmute(MsiJoinTransaction(htransactionhandle.into_param().abi(), ::std::mem::transmute(dwtransactionattributes), ::std::mem::transmute(phchangeofownerevent)))
8183     }
8184     #[cfg(not(windows))]
8185     unimplemented!("Unsupported target OS");
8186 }
8187 #[cfg(feature = "Win32_Foundation")]
8188 #[inline]
MsiLocateComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE8189 pub unsafe fn MsiLocateComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcomponent: Param0, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE {
8190     #[cfg(windows)]
8191     {
8192         #[link(name = "windows")]
8193         extern "system" {
8194             fn MsiLocateComponentA(szcomponent: super::super::Foundation::PSTR, lppathbuf: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> INSTALLSTATE;
8195         }
8196         ::std::mem::transmute(MsiLocateComponentA(szcomponent.into_param().abi(), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchbuf)))
8197     }
8198     #[cfg(not(windows))]
8199     unimplemented!("Unsupported target OS");
8200 }
8201 #[cfg(feature = "Win32_Foundation")]
8202 #[inline]
MsiLocateComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE8203 pub unsafe fn MsiLocateComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcomponent: Param0, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE {
8204     #[cfg(windows)]
8205     {
8206         #[link(name = "windows")]
8207         extern "system" {
8208             fn MsiLocateComponentW(szcomponent: super::super::Foundation::PWSTR, lppathbuf: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> INSTALLSTATE;
8209         }
8210         ::std::mem::transmute(MsiLocateComponentW(szcomponent.into_param().abi(), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchbuf)))
8211     }
8212     #[cfg(not(windows))]
8213     unimplemented!("Unsupported target OS");
8214 }
8215 #[cfg(feature = "Win32_Foundation")]
8216 #[inline]
MsiNotifySidChangeA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(poldsid: Param0, pnewsid: Param1) -> u328217 pub unsafe fn MsiNotifySidChangeA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(poldsid: Param0, pnewsid: Param1) -> u32 {
8218     #[cfg(windows)]
8219     {
8220         #[link(name = "windows")]
8221         extern "system" {
8222             fn MsiNotifySidChangeA(poldsid: super::super::Foundation::PSTR, pnewsid: super::super::Foundation::PSTR) -> u32;
8223         }
8224         ::std::mem::transmute(MsiNotifySidChangeA(poldsid.into_param().abi(), pnewsid.into_param().abi()))
8225     }
8226     #[cfg(not(windows))]
8227     unimplemented!("Unsupported target OS");
8228 }
8229 #[cfg(feature = "Win32_Foundation")]
8230 #[inline]
MsiNotifySidChangeW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(poldsid: Param0, pnewsid: Param1) -> u328231 pub unsafe fn MsiNotifySidChangeW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(poldsid: Param0, pnewsid: Param1) -> u32 {
8232     #[cfg(windows)]
8233     {
8234         #[link(name = "windows")]
8235         extern "system" {
8236             fn MsiNotifySidChangeW(poldsid: super::super::Foundation::PWSTR, pnewsid: super::super::Foundation::PWSTR) -> u32;
8237         }
8238         ::std::mem::transmute(MsiNotifySidChangeW(poldsid.into_param().abi(), pnewsid.into_param().abi()))
8239     }
8240     #[cfg(not(windows))]
8241     unimplemented!("Unsupported target OS");
8242 }
8243 #[cfg(feature = "Win32_Foundation")]
8244 #[inline]
MsiOpenDatabaseA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szdatabasepath: Param0, szpersist: Param1, phdatabase: *mut MSIHANDLE) -> u328245 pub unsafe fn MsiOpenDatabaseA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szdatabasepath: Param0, szpersist: Param1, phdatabase: *mut MSIHANDLE) -> u32 {
8246     #[cfg(windows)]
8247     {
8248         #[link(name = "windows")]
8249         extern "system" {
8250             fn MsiOpenDatabaseA(szdatabasepath: super::super::Foundation::PSTR, szpersist: super::super::Foundation::PSTR, phdatabase: *mut MSIHANDLE) -> u32;
8251         }
8252         ::std::mem::transmute(MsiOpenDatabaseA(szdatabasepath.into_param().abi(), szpersist.into_param().abi(), ::std::mem::transmute(phdatabase)))
8253     }
8254     #[cfg(not(windows))]
8255     unimplemented!("Unsupported target OS");
8256 }
8257 #[cfg(feature = "Win32_Foundation")]
8258 #[inline]
MsiOpenDatabaseW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szdatabasepath: Param0, szpersist: Param1, phdatabase: *mut MSIHANDLE) -> u328259 pub unsafe fn MsiOpenDatabaseW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szdatabasepath: Param0, szpersist: Param1, phdatabase: *mut MSIHANDLE) -> u32 {
8260     #[cfg(windows)]
8261     {
8262         #[link(name = "windows")]
8263         extern "system" {
8264             fn MsiOpenDatabaseW(szdatabasepath: super::super::Foundation::PWSTR, szpersist: super::super::Foundation::PWSTR, phdatabase: *mut MSIHANDLE) -> u32;
8265         }
8266         ::std::mem::transmute(MsiOpenDatabaseW(szdatabasepath.into_param().abi(), szpersist.into_param().abi(), ::std::mem::transmute(phdatabase)))
8267     }
8268     #[cfg(not(windows))]
8269     unimplemented!("Unsupported target OS");
8270 }
8271 #[cfg(feature = "Win32_Foundation")]
8272 #[inline]
MsiOpenPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, hproduct: *mut MSIHANDLE) -> u328273 pub unsafe fn MsiOpenPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, hproduct: *mut MSIHANDLE) -> u32 {
8274     #[cfg(windows)]
8275     {
8276         #[link(name = "windows")]
8277         extern "system" {
8278             fn MsiOpenPackageA(szpackagepath: super::super::Foundation::PSTR, hproduct: *mut MSIHANDLE) -> u32;
8279         }
8280         ::std::mem::transmute(MsiOpenPackageA(szpackagepath.into_param().abi(), ::std::mem::transmute(hproduct)))
8281     }
8282     #[cfg(not(windows))]
8283     unimplemented!("Unsupported target OS");
8284 }
8285 #[cfg(feature = "Win32_Foundation")]
8286 #[inline]
MsiOpenPackageExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u328287 pub unsafe fn MsiOpenPackageExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u32 {
8288     #[cfg(windows)]
8289     {
8290         #[link(name = "windows")]
8291         extern "system" {
8292             fn MsiOpenPackageExA(szpackagepath: super::super::Foundation::PSTR, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u32;
8293         }
8294         ::std::mem::transmute(MsiOpenPackageExA(szpackagepath.into_param().abi(), ::std::mem::transmute(dwoptions), ::std::mem::transmute(hproduct)))
8295     }
8296     #[cfg(not(windows))]
8297     unimplemented!("Unsupported target OS");
8298 }
8299 #[cfg(feature = "Win32_Foundation")]
8300 #[inline]
MsiOpenPackageExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u328301 pub unsafe fn MsiOpenPackageExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u32 {
8302     #[cfg(windows)]
8303     {
8304         #[link(name = "windows")]
8305         extern "system" {
8306             fn MsiOpenPackageExW(szpackagepath: super::super::Foundation::PWSTR, dwoptions: u32, hproduct: *mut MSIHANDLE) -> u32;
8307         }
8308         ::std::mem::transmute(MsiOpenPackageExW(szpackagepath.into_param().abi(), ::std::mem::transmute(dwoptions), ::std::mem::transmute(hproduct)))
8309     }
8310     #[cfg(not(windows))]
8311     unimplemented!("Unsupported target OS");
8312 }
8313 #[cfg(feature = "Win32_Foundation")]
8314 #[inline]
MsiOpenPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, hproduct: *mut MSIHANDLE) -> u328315 pub unsafe fn MsiOpenPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0, hproduct: *mut MSIHANDLE) -> u32 {
8316     #[cfg(windows)]
8317     {
8318         #[link(name = "windows")]
8319         extern "system" {
8320             fn MsiOpenPackageW(szpackagepath: super::super::Foundation::PWSTR, hproduct: *mut MSIHANDLE) -> u32;
8321         }
8322         ::std::mem::transmute(MsiOpenPackageW(szpackagepath.into_param().abi(), ::std::mem::transmute(hproduct)))
8323     }
8324     #[cfg(not(windows))]
8325     unimplemented!("Unsupported target OS");
8326 }
8327 #[cfg(feature = "Win32_Foundation")]
8328 #[inline]
MsiOpenProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, hproduct: *mut MSIHANDLE) -> u328329 pub unsafe fn MsiOpenProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, hproduct: *mut MSIHANDLE) -> u32 {
8330     #[cfg(windows)]
8331     {
8332         #[link(name = "windows")]
8333         extern "system" {
8334             fn MsiOpenProductA(szproduct: super::super::Foundation::PSTR, hproduct: *mut MSIHANDLE) -> u32;
8335         }
8336         ::std::mem::transmute(MsiOpenProductA(szproduct.into_param().abi(), ::std::mem::transmute(hproduct)))
8337     }
8338     #[cfg(not(windows))]
8339     unimplemented!("Unsupported target OS");
8340 }
8341 #[cfg(feature = "Win32_Foundation")]
8342 #[inline]
MsiOpenProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, hproduct: *mut MSIHANDLE) -> u328343 pub unsafe fn MsiOpenProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, hproduct: *mut MSIHANDLE) -> u32 {
8344     #[cfg(windows)]
8345     {
8346         #[link(name = "windows")]
8347         extern "system" {
8348             fn MsiOpenProductW(szproduct: super::super::Foundation::PWSTR, hproduct: *mut MSIHANDLE) -> u32;
8349         }
8350         ::std::mem::transmute(MsiOpenProductW(szproduct.into_param().abi(), ::std::mem::transmute(hproduct)))
8351     }
8352     #[cfg(not(windows))]
8353     unimplemented!("Unsupported target OS");
8354 }
8355 #[cfg(feature = "Win32_Foundation")]
8356 #[inline]
MsiPreviewBillboardA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hpreview: Param0, szcontrolname: Param1, szbillboard: Param2) -> u328357 pub unsafe fn MsiPreviewBillboardA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hpreview: Param0, szcontrolname: Param1, szbillboard: Param2) -> u32 {
8358     #[cfg(windows)]
8359     {
8360         #[link(name = "windows")]
8361         extern "system" {
8362             fn MsiPreviewBillboardA(hpreview: MSIHANDLE, szcontrolname: super::super::Foundation::PSTR, szbillboard: super::super::Foundation::PSTR) -> u32;
8363         }
8364         ::std::mem::transmute(MsiPreviewBillboardA(hpreview.into_param().abi(), szcontrolname.into_param().abi(), szbillboard.into_param().abi()))
8365     }
8366     #[cfg(not(windows))]
8367     unimplemented!("Unsupported target OS");
8368 }
8369 #[cfg(feature = "Win32_Foundation")]
8370 #[inline]
MsiPreviewBillboardW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hpreview: Param0, szcontrolname: Param1, szbillboard: Param2) -> u328371 pub unsafe fn MsiPreviewBillboardW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hpreview: Param0, szcontrolname: Param1, szbillboard: Param2) -> u32 {
8372     #[cfg(windows)]
8373     {
8374         #[link(name = "windows")]
8375         extern "system" {
8376             fn MsiPreviewBillboardW(hpreview: MSIHANDLE, szcontrolname: super::super::Foundation::PWSTR, szbillboard: super::super::Foundation::PWSTR) -> u32;
8377         }
8378         ::std::mem::transmute(MsiPreviewBillboardW(hpreview.into_param().abi(), szcontrolname.into_param().abi(), szbillboard.into_param().abi()))
8379     }
8380     #[cfg(not(windows))]
8381     unimplemented!("Unsupported target OS");
8382 }
8383 #[cfg(feature = "Win32_Foundation")]
8384 #[inline]
MsiPreviewDialogA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hpreview: Param0, szdialogname: Param1) -> u328385 pub unsafe fn MsiPreviewDialogA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hpreview: Param0, szdialogname: Param1) -> u32 {
8386     #[cfg(windows)]
8387     {
8388         #[link(name = "windows")]
8389         extern "system" {
8390             fn MsiPreviewDialogA(hpreview: MSIHANDLE, szdialogname: super::super::Foundation::PSTR) -> u32;
8391         }
8392         ::std::mem::transmute(MsiPreviewDialogA(hpreview.into_param().abi(), szdialogname.into_param().abi()))
8393     }
8394     #[cfg(not(windows))]
8395     unimplemented!("Unsupported target OS");
8396 }
8397 #[cfg(feature = "Win32_Foundation")]
8398 #[inline]
MsiPreviewDialogW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hpreview: Param0, szdialogname: Param1) -> u328399 pub unsafe fn MsiPreviewDialogW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hpreview: Param0, szdialogname: Param1) -> u32 {
8400     #[cfg(windows)]
8401     {
8402         #[link(name = "windows")]
8403         extern "system" {
8404             fn MsiPreviewDialogW(hpreview: MSIHANDLE, szdialogname: super::super::Foundation::PWSTR) -> u32;
8405         }
8406         ::std::mem::transmute(MsiPreviewDialogW(hpreview.into_param().abi(), szdialogname.into_param().abi()))
8407     }
8408     #[cfg(not(windows))]
8409     unimplemented!("Unsupported target OS");
8410 }
8411 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
8412 #[inline]
MsiProcessAdvertiseScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( szscriptfile: Param0, sziconfolder: Param1, hregdata: Param2, fshortcuts: Param3, fremoveitems: Param4, ) -> u328413 pub unsafe fn MsiProcessAdvertiseScriptA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
8414     szscriptfile: Param0,
8415     sziconfolder: Param1,
8416     hregdata: Param2,
8417     fshortcuts: Param3,
8418     fremoveitems: Param4,
8419 ) -> u32 {
8420     #[cfg(windows)]
8421     {
8422         #[link(name = "windows")]
8423         extern "system" {
8424             fn MsiProcessAdvertiseScriptA(szscriptfile: super::super::Foundation::PSTR, sziconfolder: super::super::Foundation::PSTR, hregdata: super::Registry::HKEY, fshortcuts: super::super::Foundation::BOOL, fremoveitems: super::super::Foundation::BOOL) -> u32;
8425         }
8426         ::std::mem::transmute(MsiProcessAdvertiseScriptA(szscriptfile.into_param().abi(), sziconfolder.into_param().abi(), hregdata.into_param().abi(), fshortcuts.into_param().abi(), fremoveitems.into_param().abi()))
8427     }
8428     #[cfg(not(windows))]
8429     unimplemented!("Unsupported target OS");
8430 }
8431 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
8432 #[inline]
MsiProcessAdvertiseScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( szscriptfile: Param0, sziconfolder: Param1, hregdata: Param2, fshortcuts: Param3, fremoveitems: Param4, ) -> u328433 pub unsafe fn MsiProcessAdvertiseScriptW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
8434     szscriptfile: Param0,
8435     sziconfolder: Param1,
8436     hregdata: Param2,
8437     fshortcuts: Param3,
8438     fremoveitems: Param4,
8439 ) -> u32 {
8440     #[cfg(windows)]
8441     {
8442         #[link(name = "windows")]
8443         extern "system" {
8444             fn MsiProcessAdvertiseScriptW(szscriptfile: super::super::Foundation::PWSTR, sziconfolder: super::super::Foundation::PWSTR, hregdata: super::Registry::HKEY, fshortcuts: super::super::Foundation::BOOL, fremoveitems: super::super::Foundation::BOOL) -> u32;
8445         }
8446         ::std::mem::transmute(MsiProcessAdvertiseScriptW(szscriptfile.into_param().abi(), sziconfolder.into_param().abi(), hregdata.into_param().abi(), fshortcuts.into_param().abi(), fremoveitems.into_param().abi()))
8447     }
8448     #[cfg(not(windows))]
8449     unimplemented!("Unsupported target OS");
8450 }
8451 #[inline]
MsiProcessMessage<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, emessagetype: INSTALLMESSAGE, hrecord: Param2) -> i328452 pub unsafe fn MsiProcessMessage<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, emessagetype: INSTALLMESSAGE, hrecord: Param2) -> i32 {
8453     #[cfg(windows)]
8454     {
8455         #[link(name = "windows")]
8456         extern "system" {
8457             fn MsiProcessMessage(hinstall: MSIHANDLE, emessagetype: INSTALLMESSAGE, hrecord: MSIHANDLE) -> i32;
8458         }
8459         ::std::mem::transmute(MsiProcessMessage(hinstall.into_param().abi(), ::std::mem::transmute(emessagetype), hrecord.into_param().abi()))
8460     }
8461     #[cfg(not(windows))]
8462     unimplemented!("Unsupported target OS");
8463 }
8464 #[cfg(feature = "Win32_Foundation")]
8465 #[inline]
MsiProvideAssemblyA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szassemblyname: Param0, szappcontext: Param1, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u328466 pub unsafe fn MsiProvideAssemblyA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szassemblyname: Param0, szappcontext: Param1, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
8467     #[cfg(windows)]
8468     {
8469         #[link(name = "windows")]
8470         extern "system" {
8471             fn MsiProvideAssemblyA(szassemblyname: super::super::Foundation::PSTR, szappcontext: super::super::Foundation::PSTR, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
8472         }
8473         ::std::mem::transmute(MsiProvideAssemblyA(szassemblyname.into_param().abi(), szappcontext.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(dwassemblyinfo), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8474     }
8475     #[cfg(not(windows))]
8476     unimplemented!("Unsupported target OS");
8477 }
8478 #[cfg(feature = "Win32_Foundation")]
8479 #[inline]
MsiProvideAssemblyW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szassemblyname: Param0, szappcontext: Param1, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u328480 pub unsafe fn MsiProvideAssemblyW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szassemblyname: Param0, szappcontext: Param1, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
8481     #[cfg(windows)]
8482     {
8483         #[link(name = "windows")]
8484         extern "system" {
8485             fn MsiProvideAssemblyW(szassemblyname: super::super::Foundation::PWSTR, szappcontext: super::super::Foundation::PWSTR, dwinstallmode: INSTALLMODE, dwassemblyinfo: MSIASSEMBLYINFO, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
8486         }
8487         ::std::mem::transmute(MsiProvideAssemblyW(szassemblyname.into_param().abi(), szappcontext.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(dwassemblyinfo), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8488     }
8489     #[cfg(not(windows))]
8490     unimplemented!("Unsupported target OS");
8491 }
8492 #[cfg(feature = "Win32_Foundation")]
8493 #[inline]
MsiProvideComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, szcomponent: Param2, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u328494 pub unsafe fn MsiProvideComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, szcomponent: Param2, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
8495     #[cfg(windows)]
8496     {
8497         #[link(name = "windows")]
8498         extern "system" {
8499             fn MsiProvideComponentA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR, szcomponent: super::super::Foundation::PSTR, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
8500         }
8501         ::std::mem::transmute(MsiProvideComponentA(szproduct.into_param().abi(), szfeature.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8502     }
8503     #[cfg(not(windows))]
8504     unimplemented!("Unsupported target OS");
8505 }
8506 #[cfg(feature = "Win32_Foundation")]
8507 #[inline]
MsiProvideComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, szcomponent: Param2, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u328508 pub unsafe fn MsiProvideComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, szcomponent: Param2, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
8509     #[cfg(windows)]
8510     {
8511         #[link(name = "windows")]
8512         extern "system" {
8513             fn MsiProvideComponentW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR, szcomponent: super::super::Foundation::PWSTR, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
8514         }
8515         ::std::mem::transmute(MsiProvideComponentW(szproduct.into_param().abi(), szfeature.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8516     }
8517     #[cfg(not(windows))]
8518     unimplemented!("Unsupported target OS");
8519 }
8520 #[cfg(feature = "Win32_Foundation")]
8521 #[inline]
MsiProvideQualifiedComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u328522 pub unsafe fn MsiProvideQualifiedComponentA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
8523     #[cfg(windows)]
8524     {
8525         #[link(name = "windows")]
8526         extern "system" {
8527             fn MsiProvideQualifiedComponentA(szcategory: super::super::Foundation::PSTR, szqualifier: super::super::Foundation::PSTR, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
8528         }
8529         ::std::mem::transmute(MsiProvideQualifiedComponentA(szcategory.into_param().abi(), szqualifier.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8530     }
8531     #[cfg(not(windows))]
8532     unimplemented!("Unsupported target OS");
8533 }
8534 #[cfg(feature = "Win32_Foundation")]
8535 #[inline]
MsiProvideQualifiedComponentExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, szproduct: Param3, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u328536 pub unsafe fn MsiProvideQualifiedComponentExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, szproduct: Param3, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32 {
8537     #[cfg(windows)]
8538     {
8539         #[link(name = "windows")]
8540         extern "system" {
8541             fn MsiProvideQualifiedComponentExA(szcategory: super::super::Foundation::PSTR, szqualifier: super::super::Foundation::PSTR, dwinstallmode: INSTALLMODE, szproduct: super::super::Foundation::PSTR, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PSTR, pcchpathbuf: *mut u32) -> u32;
8542         }
8543         ::std::mem::transmute(MsiProvideQualifiedComponentExA(szcategory.into_param().abi(), szqualifier.into_param().abi(), ::std::mem::transmute(dwinstallmode), szproduct.into_param().abi(), ::std::mem::transmute(dwunused1), ::std::mem::transmute(dwunused2), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8544     }
8545     #[cfg(not(windows))]
8546     unimplemented!("Unsupported target OS");
8547 }
8548 #[cfg(feature = "Win32_Foundation")]
8549 #[inline]
MsiProvideQualifiedComponentExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, szproduct: Param3, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u328550 pub unsafe fn MsiProvideQualifiedComponentExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, szproduct: Param3, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
8551     #[cfg(windows)]
8552     {
8553         #[link(name = "windows")]
8554         extern "system" {
8555             fn MsiProvideQualifiedComponentExW(szcategory: super::super::Foundation::PWSTR, szqualifier: super::super::Foundation::PWSTR, dwinstallmode: INSTALLMODE, szproduct: super::super::Foundation::PWSTR, dwunused1: u32, dwunused2: u32, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
8556         }
8557         ::std::mem::transmute(MsiProvideQualifiedComponentExW(szcategory.into_param().abi(), szqualifier.into_param().abi(), ::std::mem::transmute(dwinstallmode), szproduct.into_param().abi(), ::std::mem::transmute(dwunused1), ::std::mem::transmute(dwunused2), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8558     }
8559     #[cfg(not(windows))]
8560     unimplemented!("Unsupported target OS");
8561 }
8562 #[cfg(feature = "Win32_Foundation")]
8563 #[inline]
MsiProvideQualifiedComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u328564 pub unsafe fn MsiProvideQualifiedComponentW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcategory: Param0, szqualifier: Param1, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32 {
8565     #[cfg(windows)]
8566     {
8567         #[link(name = "windows")]
8568         extern "system" {
8569             fn MsiProvideQualifiedComponentW(szcategory: super::super::Foundation::PWSTR, szqualifier: super::super::Foundation::PWSTR, dwinstallmode: INSTALLMODE, lppathbuf: super::super::Foundation::PWSTR, pcchpathbuf: *mut u32) -> u32;
8570         }
8571         ::std::mem::transmute(MsiProvideQualifiedComponentW(szcategory.into_param().abi(), szqualifier.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(lppathbuf), ::std::mem::transmute(pcchpathbuf)))
8572     }
8573     #[cfg(not(windows))]
8574     unimplemented!("Unsupported target OS");
8575 }
8576 #[cfg(feature = "Win32_Foundation")]
8577 #[inline]
MsiQueryComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: Param3, pdwstate: *mut INSTALLSTATE) -> u328578 pub unsafe fn MsiQueryComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: Param3, pdwstate: *mut INSTALLSTATE) -> u32 {
8579     #[cfg(windows)]
8580     {
8581         #[link(name = "windows")]
8582         extern "system" {
8583             fn MsiQueryComponentStateA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: super::super::Foundation::PSTR, pdwstate: *mut INSTALLSTATE) -> u32;
8584         }
8585         ::std::mem::transmute(MsiQueryComponentStateA(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szcomponentcode.into_param().abi(), ::std::mem::transmute(pdwstate)))
8586     }
8587     #[cfg(not(windows))]
8588     unimplemented!("Unsupported target OS");
8589 }
8590 #[cfg(feature = "Win32_Foundation")]
8591 #[inline]
MsiQueryComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: Param3, pdwstate: *mut INSTALLSTATE) -> u328592 pub unsafe fn MsiQueryComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: Param3, pdwstate: *mut INSTALLSTATE) -> u32 {
8593     #[cfg(windows)]
8594     {
8595         #[link(name = "windows")]
8596         extern "system" {
8597             fn MsiQueryComponentStateW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, szcomponentcode: super::super::Foundation::PWSTR, pdwstate: *mut INSTALLSTATE) -> u32;
8598         }
8599         ::std::mem::transmute(MsiQueryComponentStateW(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szcomponentcode.into_param().abi(), ::std::mem::transmute(pdwstate)))
8600     }
8601     #[cfg(not(windows))]
8602     unimplemented!("Unsupported target OS");
8603 }
8604 #[cfg(feature = "Win32_Foundation")]
8605 #[inline]
MsiQueryFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE8606 pub unsafe fn MsiQueryFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE {
8607     #[cfg(windows)]
8608     {
8609         #[link(name = "windows")]
8610         extern "system" {
8611             fn MsiQueryFeatureStateA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR) -> INSTALLSTATE;
8612         }
8613         ::std::mem::transmute(MsiQueryFeatureStateA(szproduct.into_param().abi(), szfeature.into_param().abi()))
8614     }
8615     #[cfg(not(windows))]
8616     unimplemented!("Unsupported target OS");
8617 }
8618 #[cfg(feature = "Win32_Foundation")]
8619 #[inline]
MsiQueryFeatureStateExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szfeature: Param3, pdwstate: *mut INSTALLSTATE) -> u328620 pub unsafe fn MsiQueryFeatureStateExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szfeature: Param3, pdwstate: *mut INSTALLSTATE) -> u32 {
8621     #[cfg(windows)]
8622     {
8623         #[link(name = "windows")]
8624         extern "system" {
8625             fn MsiQueryFeatureStateExA(szproductcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, szfeature: super::super::Foundation::PSTR, pdwstate: *mut INSTALLSTATE) -> u32;
8626         }
8627         ::std::mem::transmute(MsiQueryFeatureStateExA(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szfeature.into_param().abi(), ::std::mem::transmute(pdwstate)))
8628     }
8629     #[cfg(not(windows))]
8630     unimplemented!("Unsupported target OS");
8631 }
8632 #[cfg(feature = "Win32_Foundation")]
8633 #[inline]
MsiQueryFeatureStateExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szfeature: Param3, pdwstate: *mut INSTALLSTATE) -> u328634 pub unsafe fn MsiQueryFeatureStateExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, szfeature: Param3, pdwstate: *mut INSTALLSTATE) -> u32 {
8635     #[cfg(windows)]
8636     {
8637         #[link(name = "windows")]
8638         extern "system" {
8639             fn MsiQueryFeatureStateExW(szproductcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, szfeature: super::super::Foundation::PWSTR, pdwstate: *mut INSTALLSTATE) -> u32;
8640         }
8641         ::std::mem::transmute(MsiQueryFeatureStateExW(szproductcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), szfeature.into_param().abi(), ::std::mem::transmute(pdwstate)))
8642     }
8643     #[cfg(not(windows))]
8644     unimplemented!("Unsupported target OS");
8645 }
8646 #[cfg(feature = "Win32_Foundation")]
8647 #[inline]
MsiQueryFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE8648 pub unsafe fn MsiQueryFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE {
8649     #[cfg(windows)]
8650     {
8651         #[link(name = "windows")]
8652         extern "system" {
8653             fn MsiQueryFeatureStateW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR) -> INSTALLSTATE;
8654         }
8655         ::std::mem::transmute(MsiQueryFeatureStateW(szproduct.into_param().abi(), szfeature.into_param().abi()))
8656     }
8657     #[cfg(not(windows))]
8658     unimplemented!("Unsupported target OS");
8659 }
8660 #[cfg(feature = "Win32_Foundation")]
8661 #[inline]
MsiQueryProductStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0) -> INSTALLSTATE8662 pub unsafe fn MsiQueryProductStateA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0) -> INSTALLSTATE {
8663     #[cfg(windows)]
8664     {
8665         #[link(name = "windows")]
8666         extern "system" {
8667             fn MsiQueryProductStateA(szproduct: super::super::Foundation::PSTR) -> INSTALLSTATE;
8668         }
8669         ::std::mem::transmute(MsiQueryProductStateA(szproduct.into_param().abi()))
8670     }
8671     #[cfg(not(windows))]
8672     unimplemented!("Unsupported target OS");
8673 }
8674 #[cfg(feature = "Win32_Foundation")]
8675 #[inline]
MsiQueryProductStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0) -> INSTALLSTATE8676 pub unsafe fn MsiQueryProductStateW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0) -> INSTALLSTATE {
8677     #[cfg(windows)]
8678     {
8679         #[link(name = "windows")]
8680         extern "system" {
8681             fn MsiQueryProductStateW(szproduct: super::super::Foundation::PWSTR) -> INSTALLSTATE;
8682         }
8683         ::std::mem::transmute(MsiQueryProductStateW(szproduct.into_param().abi()))
8684     }
8685     #[cfg(not(windows))]
8686     unimplemented!("Unsupported target OS");
8687 }
8688 #[inline]
MsiRecordClearData<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0) -> u328689 pub unsafe fn MsiRecordClearData<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0) -> u32 {
8690     #[cfg(windows)]
8691     {
8692         #[link(name = "windows")]
8693         extern "system" {
8694             fn MsiRecordClearData(hrecord: MSIHANDLE) -> u32;
8695         }
8696         ::std::mem::transmute(MsiRecordClearData(hrecord.into_param().abi()))
8697     }
8698     #[cfg(not(windows))]
8699     unimplemented!("Unsupported target OS");
8700 }
8701 #[inline]
MsiRecordDataSize<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> u328702 pub unsafe fn MsiRecordDataSize<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> u32 {
8703     #[cfg(windows)]
8704     {
8705         #[link(name = "windows")]
8706         extern "system" {
8707             fn MsiRecordDataSize(hrecord: MSIHANDLE, ifield: u32) -> u32;
8708         }
8709         ::std::mem::transmute(MsiRecordDataSize(hrecord.into_param().abi(), ::std::mem::transmute(ifield)))
8710     }
8711     #[cfg(not(windows))]
8712     unimplemented!("Unsupported target OS");
8713 }
8714 #[inline]
MsiRecordGetFieldCount<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0) -> u328715 pub unsafe fn MsiRecordGetFieldCount<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0) -> u32 {
8716     #[cfg(windows)]
8717     {
8718         #[link(name = "windows")]
8719         extern "system" {
8720             fn MsiRecordGetFieldCount(hrecord: MSIHANDLE) -> u32;
8721         }
8722         ::std::mem::transmute(MsiRecordGetFieldCount(hrecord.into_param().abi()))
8723     }
8724     #[cfg(not(windows))]
8725     unimplemented!("Unsupported target OS");
8726 }
8727 #[inline]
MsiRecordGetInteger<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> i328728 pub unsafe fn MsiRecordGetInteger<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> i32 {
8729     #[cfg(windows)]
8730     {
8731         #[link(name = "windows")]
8732         extern "system" {
8733             fn MsiRecordGetInteger(hrecord: MSIHANDLE, ifield: u32) -> i32;
8734         }
8735         ::std::mem::transmute(MsiRecordGetInteger(hrecord.into_param().abi(), ::std::mem::transmute(ifield)))
8736     }
8737     #[cfg(not(windows))]
8738     unimplemented!("Unsupported target OS");
8739 }
8740 #[cfg(feature = "Win32_Foundation")]
8741 #[inline]
MsiRecordGetStringA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u328742 pub unsafe fn MsiRecordGetStringA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
8743     #[cfg(windows)]
8744     {
8745         #[link(name = "windows")]
8746         extern "system" {
8747             fn MsiRecordGetStringA(hrecord: MSIHANDLE, ifield: u32, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
8748         }
8749         ::std::mem::transmute(MsiRecordGetStringA(hrecord.into_param().abi(), ::std::mem::transmute(ifield), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
8750     }
8751     #[cfg(not(windows))]
8752     unimplemented!("Unsupported target OS");
8753 }
8754 #[cfg(feature = "Win32_Foundation")]
8755 #[inline]
MsiRecordGetStringW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u328756 pub unsafe fn MsiRecordGetStringW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
8757     #[cfg(windows)]
8758     {
8759         #[link(name = "windows")]
8760         extern "system" {
8761             fn MsiRecordGetStringW(hrecord: MSIHANDLE, ifield: u32, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
8762         }
8763         ::std::mem::transmute(MsiRecordGetStringW(hrecord.into_param().abi(), ::std::mem::transmute(ifield), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
8764     }
8765     #[cfg(not(windows))]
8766     unimplemented!("Unsupported target OS");
8767 }
8768 #[cfg(feature = "Win32_Foundation")]
8769 #[inline]
MsiRecordIsNull<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> super::super::Foundation::BOOL8770 pub unsafe fn MsiRecordIsNull<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32) -> super::super::Foundation::BOOL {
8771     #[cfg(windows)]
8772     {
8773         #[link(name = "windows")]
8774         extern "system" {
8775             fn MsiRecordIsNull(hrecord: MSIHANDLE, ifield: u32) -> super::super::Foundation::BOOL;
8776         }
8777         ::std::mem::transmute(MsiRecordIsNull(hrecord.into_param().abi(), ::std::mem::transmute(ifield)))
8778     }
8779     #[cfg(not(windows))]
8780     unimplemented!("Unsupported target OS");
8781 }
8782 #[cfg(feature = "Win32_Foundation")]
8783 #[inline]
MsiRecordReadStream<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szdatabuf: super::super::Foundation::PSTR, pcbdatabuf: *mut u32) -> u328784 pub unsafe fn MsiRecordReadStream<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, szdatabuf: super::super::Foundation::PSTR, pcbdatabuf: *mut u32) -> u32 {
8785     #[cfg(windows)]
8786     {
8787         #[link(name = "windows")]
8788         extern "system" {
8789             fn MsiRecordReadStream(hrecord: MSIHANDLE, ifield: u32, szdatabuf: super::super::Foundation::PSTR, pcbdatabuf: *mut u32) -> u32;
8790         }
8791         ::std::mem::transmute(MsiRecordReadStream(hrecord.into_param().abi(), ::std::mem::transmute(ifield), ::std::mem::transmute(szdatabuf), ::std::mem::transmute(pcbdatabuf)))
8792     }
8793     #[cfg(not(windows))]
8794     unimplemented!("Unsupported target OS");
8795 }
8796 #[inline]
MsiRecordSetInteger<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, ivalue: i32) -> u328797 pub unsafe fn MsiRecordSetInteger<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hrecord: Param0, ifield: u32, ivalue: i32) -> u32 {
8798     #[cfg(windows)]
8799     {
8800         #[link(name = "windows")]
8801         extern "system" {
8802             fn MsiRecordSetInteger(hrecord: MSIHANDLE, ifield: u32, ivalue: i32) -> u32;
8803         }
8804         ::std::mem::transmute(MsiRecordSetInteger(hrecord.into_param().abi(), ::std::mem::transmute(ifield), ::std::mem::transmute(ivalue)))
8805     }
8806     #[cfg(not(windows))]
8807     unimplemented!("Unsupported target OS");
8808 }
8809 #[cfg(feature = "Win32_Foundation")]
8810 #[inline]
MsiRecordSetStreamA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hrecord: Param0, ifield: u32, szfilepath: Param2) -> u328811 pub unsafe fn MsiRecordSetStreamA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hrecord: Param0, ifield: u32, szfilepath: Param2) -> u32 {
8812     #[cfg(windows)]
8813     {
8814         #[link(name = "windows")]
8815         extern "system" {
8816             fn MsiRecordSetStreamA(hrecord: MSIHANDLE, ifield: u32, szfilepath: super::super::Foundation::PSTR) -> u32;
8817         }
8818         ::std::mem::transmute(MsiRecordSetStreamA(hrecord.into_param().abi(), ::std::mem::transmute(ifield), szfilepath.into_param().abi()))
8819     }
8820     #[cfg(not(windows))]
8821     unimplemented!("Unsupported target OS");
8822 }
8823 #[cfg(feature = "Win32_Foundation")]
8824 #[inline]
MsiRecordSetStreamW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hrecord: Param0, ifield: u32, szfilepath: Param2) -> u328825 pub unsafe fn MsiRecordSetStreamW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hrecord: Param0, ifield: u32, szfilepath: Param2) -> u32 {
8826     #[cfg(windows)]
8827     {
8828         #[link(name = "windows")]
8829         extern "system" {
8830             fn MsiRecordSetStreamW(hrecord: MSIHANDLE, ifield: u32, szfilepath: super::super::Foundation::PWSTR) -> u32;
8831         }
8832         ::std::mem::transmute(MsiRecordSetStreamW(hrecord.into_param().abi(), ::std::mem::transmute(ifield), szfilepath.into_param().abi()))
8833     }
8834     #[cfg(not(windows))]
8835     unimplemented!("Unsupported target OS");
8836 }
8837 #[cfg(feature = "Win32_Foundation")]
8838 #[inline]
MsiRecordSetStringA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hrecord: Param0, ifield: u32, szvalue: Param2) -> u328839 pub unsafe fn MsiRecordSetStringA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hrecord: Param0, ifield: u32, szvalue: Param2) -> u32 {
8840     #[cfg(windows)]
8841     {
8842         #[link(name = "windows")]
8843         extern "system" {
8844             fn MsiRecordSetStringA(hrecord: MSIHANDLE, ifield: u32, szvalue: super::super::Foundation::PSTR) -> u32;
8845         }
8846         ::std::mem::transmute(MsiRecordSetStringA(hrecord.into_param().abi(), ::std::mem::transmute(ifield), szvalue.into_param().abi()))
8847     }
8848     #[cfg(not(windows))]
8849     unimplemented!("Unsupported target OS");
8850 }
8851 #[cfg(feature = "Win32_Foundation")]
8852 #[inline]
MsiRecordSetStringW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hrecord: Param0, ifield: u32, szvalue: Param2) -> u328853 pub unsafe fn MsiRecordSetStringW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hrecord: Param0, ifield: u32, szvalue: Param2) -> u32 {
8854     #[cfg(windows)]
8855     {
8856         #[link(name = "windows")]
8857         extern "system" {
8858             fn MsiRecordSetStringW(hrecord: MSIHANDLE, ifield: u32, szvalue: super::super::Foundation::PWSTR) -> u32;
8859         }
8860         ::std::mem::transmute(MsiRecordSetStringW(hrecord.into_param().abi(), ::std::mem::transmute(ifield), szvalue.into_param().abi()))
8861     }
8862     #[cfg(not(windows))]
8863     unimplemented!("Unsupported target OS");
8864 }
8865 #[cfg(feature = "Win32_Foundation")]
8866 #[inline]
MsiReinstallFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, dwreinstallmode: REINSTALLMODE) -> u328867 pub unsafe fn MsiReinstallFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, dwreinstallmode: REINSTALLMODE) -> u32 {
8868     #[cfg(windows)]
8869     {
8870         #[link(name = "windows")]
8871         extern "system" {
8872             fn MsiReinstallFeatureA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR, dwreinstallmode: REINSTALLMODE) -> u32;
8873         }
8874         ::std::mem::transmute(MsiReinstallFeatureA(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwreinstallmode)))
8875     }
8876     #[cfg(not(windows))]
8877     unimplemented!("Unsupported target OS");
8878 }
8879 #[cfg(feature = "Win32_Foundation")]
8880 #[inline]
MsiReinstallFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, dwreinstallmode: REINSTALLMODE) -> u328881 pub unsafe fn MsiReinstallFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, dwreinstallmode: REINSTALLMODE) -> u32 {
8882     #[cfg(windows)]
8883     {
8884         #[link(name = "windows")]
8885         extern "system" {
8886             fn MsiReinstallFeatureW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR, dwreinstallmode: REINSTALLMODE) -> u32;
8887         }
8888         ::std::mem::transmute(MsiReinstallFeatureW(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwreinstallmode)))
8889     }
8890     #[cfg(not(windows))]
8891     unimplemented!("Unsupported target OS");
8892 }
8893 #[cfg(feature = "Win32_Foundation")]
8894 #[inline]
MsiReinstallProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szreinstallmode: REINSTALLMODE) -> u328895 pub unsafe fn MsiReinstallProductA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szreinstallmode: REINSTALLMODE) -> u32 {
8896     #[cfg(windows)]
8897     {
8898         #[link(name = "windows")]
8899         extern "system" {
8900             fn MsiReinstallProductA(szproduct: super::super::Foundation::PSTR, szreinstallmode: REINSTALLMODE) -> u32;
8901         }
8902         ::std::mem::transmute(MsiReinstallProductA(szproduct.into_param().abi(), ::std::mem::transmute(szreinstallmode)))
8903     }
8904     #[cfg(not(windows))]
8905     unimplemented!("Unsupported target OS");
8906 }
8907 #[cfg(feature = "Win32_Foundation")]
8908 #[inline]
MsiReinstallProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szreinstallmode: REINSTALLMODE) -> u328909 pub unsafe fn MsiReinstallProductW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szreinstallmode: REINSTALLMODE) -> u32 {
8910     #[cfg(windows)]
8911     {
8912         #[link(name = "windows")]
8913         extern "system" {
8914             fn MsiReinstallProductW(szproduct: super::super::Foundation::PWSTR, szreinstallmode: REINSTALLMODE) -> u32;
8915         }
8916         ::std::mem::transmute(MsiReinstallProductW(szproduct.into_param().abi(), ::std::mem::transmute(szreinstallmode)))
8917     }
8918     #[cfg(not(windows))]
8919     unimplemented!("Unsupported target OS");
8920 }
8921 #[cfg(feature = "Win32_Foundation")]
8922 #[inline]
MsiRemovePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchlist: Param0, szproductcode: Param1, euninstalltype: INSTALLTYPE, szpropertylist: Param3) -> u328923 pub unsafe fn MsiRemovePatchesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpatchlist: Param0, szproductcode: Param1, euninstalltype: INSTALLTYPE, szpropertylist: Param3) -> u32 {
8924     #[cfg(windows)]
8925     {
8926         #[link(name = "windows")]
8927         extern "system" {
8928             fn MsiRemovePatchesA(szpatchlist: super::super::Foundation::PSTR, szproductcode: super::super::Foundation::PSTR, euninstalltype: INSTALLTYPE, szpropertylist: super::super::Foundation::PSTR) -> u32;
8929         }
8930         ::std::mem::transmute(MsiRemovePatchesA(szpatchlist.into_param().abi(), szproductcode.into_param().abi(), ::std::mem::transmute(euninstalltype), szpropertylist.into_param().abi()))
8931     }
8932     #[cfg(not(windows))]
8933     unimplemented!("Unsupported target OS");
8934 }
8935 #[cfg(feature = "Win32_Foundation")]
8936 #[inline]
MsiRemovePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchlist: Param0, szproductcode: Param1, euninstalltype: INSTALLTYPE, szpropertylist: Param3) -> u328937 pub unsafe fn MsiRemovePatchesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpatchlist: Param0, szproductcode: Param1, euninstalltype: INSTALLTYPE, szpropertylist: Param3) -> u32 {
8938     #[cfg(windows)]
8939     {
8940         #[link(name = "windows")]
8941         extern "system" {
8942             fn MsiRemovePatchesW(szpatchlist: super::super::Foundation::PWSTR, szproductcode: super::super::Foundation::PWSTR, euninstalltype: INSTALLTYPE, szpropertylist: super::super::Foundation::PWSTR) -> u32;
8943         }
8944         ::std::mem::transmute(MsiRemovePatchesW(szpatchlist.into_param().abi(), szproductcode.into_param().abi(), ::std::mem::transmute(euninstalltype), szpropertylist.into_param().abi()))
8945     }
8946     #[cfg(not(windows))]
8947     unimplemented!("Unsupported target OS");
8948 }
8949 #[cfg(feature = "Win32_Foundation")]
8950 #[inline]
MsiSequenceA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, sztable: Param1, isequencemode: i32) -> u328951 pub unsafe fn MsiSequenceA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, sztable: Param1, isequencemode: i32) -> u32 {
8952     #[cfg(windows)]
8953     {
8954         #[link(name = "windows")]
8955         extern "system" {
8956             fn MsiSequenceA(hinstall: MSIHANDLE, sztable: super::super::Foundation::PSTR, isequencemode: i32) -> u32;
8957         }
8958         ::std::mem::transmute(MsiSequenceA(hinstall.into_param().abi(), sztable.into_param().abi(), ::std::mem::transmute(isequencemode)))
8959     }
8960     #[cfg(not(windows))]
8961     unimplemented!("Unsupported target OS");
8962 }
8963 #[cfg(feature = "Win32_Foundation")]
8964 #[inline]
MsiSequenceW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, sztable: Param1, isequencemode: i32) -> u328965 pub unsafe fn MsiSequenceW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, sztable: Param1, isequencemode: i32) -> u32 {
8966     #[cfg(windows)]
8967     {
8968         #[link(name = "windows")]
8969         extern "system" {
8970             fn MsiSequenceW(hinstall: MSIHANDLE, sztable: super::super::Foundation::PWSTR, isequencemode: i32) -> u32;
8971         }
8972         ::std::mem::transmute(MsiSequenceW(hinstall.into_param().abi(), sztable.into_param().abi(), ::std::mem::transmute(isequencemode)))
8973     }
8974     #[cfg(not(windows))]
8975     unimplemented!("Unsupported target OS");
8976 }
8977 #[cfg(feature = "Win32_Foundation")]
8978 #[inline]
MsiSetComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, istate: INSTALLSTATE) -> u328979 pub unsafe fn MsiSetComponentStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szcomponent: Param1, istate: INSTALLSTATE) -> u32 {
8980     #[cfg(windows)]
8981     {
8982         #[link(name = "windows")]
8983         extern "system" {
8984             fn MsiSetComponentStateA(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PSTR, istate: INSTALLSTATE) -> u32;
8985         }
8986         ::std::mem::transmute(MsiSetComponentStateA(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(istate)))
8987     }
8988     #[cfg(not(windows))]
8989     unimplemented!("Unsupported target OS");
8990 }
8991 #[cfg(feature = "Win32_Foundation")]
8992 #[inline]
MsiSetComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, istate: INSTALLSTATE) -> u328993 pub unsafe fn MsiSetComponentStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szcomponent: Param1, istate: INSTALLSTATE) -> u32 {
8994     #[cfg(windows)]
8995     {
8996         #[link(name = "windows")]
8997         extern "system" {
8998             fn MsiSetComponentStateW(hinstall: MSIHANDLE, szcomponent: super::super::Foundation::PWSTR, istate: INSTALLSTATE) -> u32;
8999         }
9000         ::std::mem::transmute(MsiSetComponentStateW(hinstall.into_param().abi(), szcomponent.into_param().abi(), ::std::mem::transmute(istate)))
9001     }
9002     #[cfg(not(windows))]
9003     unimplemented!("Unsupported target OS");
9004 }
9005 #[cfg(feature = "Win32_Foundation")]
9006 #[inline]
MsiSetExternalUIA(puihandler: ::std::option::Option<INSTALLUI_HANDLERA>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERA>9007 pub unsafe fn MsiSetExternalUIA(puihandler: ::std::option::Option<INSTALLUI_HANDLERA>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERA> {
9008     #[cfg(windows)]
9009     {
9010         #[link(name = "windows")]
9011         extern "system" {
9012             fn MsiSetExternalUIA(puihandler: ::windows::runtime::RawPtr, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERA>;
9013         }
9014         ::std::mem::transmute(MsiSetExternalUIA(::std::mem::transmute(puihandler), ::std::mem::transmute(dwmessagefilter), ::std::mem::transmute(pvcontext)))
9015     }
9016     #[cfg(not(windows))]
9017     unimplemented!("Unsupported target OS");
9018 }
9019 #[inline]
MsiSetExternalUIRecord(puihandler: ::std::option::Option<PINSTALLUI_HANDLER_RECORD>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void, ppuiprevhandler: ::std::option::Option<PINSTALLUI_HANDLER_RECORD>) -> u329020 pub unsafe fn MsiSetExternalUIRecord(puihandler: ::std::option::Option<PINSTALLUI_HANDLER_RECORD>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void, ppuiprevhandler: ::std::option::Option<PINSTALLUI_HANDLER_RECORD>) -> u32 {
9021     #[cfg(windows)]
9022     {
9023         #[link(name = "windows")]
9024         extern "system" {
9025             fn MsiSetExternalUIRecord(puihandler: ::windows::runtime::RawPtr, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void, ppuiprevhandler: ::windows::runtime::RawPtr) -> u32;
9026         }
9027         ::std::mem::transmute(MsiSetExternalUIRecord(::std::mem::transmute(puihandler), ::std::mem::transmute(dwmessagefilter), ::std::mem::transmute(pvcontext), ::std::mem::transmute(ppuiprevhandler)))
9028     }
9029     #[cfg(not(windows))]
9030     unimplemented!("Unsupported target OS");
9031 }
9032 #[cfg(feature = "Win32_Foundation")]
9033 #[inline]
MsiSetExternalUIW(puihandler: ::std::option::Option<INSTALLUI_HANDLERW>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERW>9034 pub unsafe fn MsiSetExternalUIW(puihandler: ::std::option::Option<INSTALLUI_HANDLERW>, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERW> {
9035     #[cfg(windows)]
9036     {
9037         #[link(name = "windows")]
9038         extern "system" {
9039             fn MsiSetExternalUIW(puihandler: ::windows::runtime::RawPtr, dwmessagefilter: u32, pvcontext: *const ::std::ffi::c_void) -> ::std::option::Option<INSTALLUI_HANDLERW>;
9040         }
9041         ::std::mem::transmute(MsiSetExternalUIW(::std::mem::transmute(puihandler), ::std::mem::transmute(dwmessagefilter), ::std::mem::transmute(pvcontext)))
9042     }
9043     #[cfg(not(windows))]
9044     unimplemented!("Unsupported target OS");
9045 }
9046 #[cfg(feature = "Win32_Foundation")]
9047 #[inline]
MsiSetFeatureAttributesA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, dwattributes: u32) -> u329048 pub unsafe fn MsiSetFeatureAttributesA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, dwattributes: u32) -> u32 {
9049     #[cfg(windows)]
9050     {
9051         #[link(name = "windows")]
9052         extern "system" {
9053             fn MsiSetFeatureAttributesA(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PSTR, dwattributes: u32) -> u32;
9054         }
9055         ::std::mem::transmute(MsiSetFeatureAttributesA(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwattributes)))
9056     }
9057     #[cfg(not(windows))]
9058     unimplemented!("Unsupported target OS");
9059 }
9060 #[cfg(feature = "Win32_Foundation")]
9061 #[inline]
MsiSetFeatureAttributesW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, dwattributes: u32) -> u329062 pub unsafe fn MsiSetFeatureAttributesW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, dwattributes: u32) -> u32 {
9063     #[cfg(windows)]
9064     {
9065         #[link(name = "windows")]
9066         extern "system" {
9067             fn MsiSetFeatureAttributesW(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, dwattributes: u32) -> u32;
9068         }
9069         ::std::mem::transmute(MsiSetFeatureAttributesW(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwattributes)))
9070     }
9071     #[cfg(not(windows))]
9072     unimplemented!("Unsupported target OS");
9073 }
9074 #[cfg(feature = "Win32_Foundation")]
9075 #[inline]
MsiSetFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, istate: INSTALLSTATE) -> u329076 pub unsafe fn MsiSetFeatureStateA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfeature: Param1, istate: INSTALLSTATE) -> u32 {
9077     #[cfg(windows)]
9078     {
9079         #[link(name = "windows")]
9080         extern "system" {
9081             fn MsiSetFeatureStateA(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PSTR, istate: INSTALLSTATE) -> u32;
9082         }
9083         ::std::mem::transmute(MsiSetFeatureStateA(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(istate)))
9084     }
9085     #[cfg(not(windows))]
9086     unimplemented!("Unsupported target OS");
9087 }
9088 #[cfg(feature = "Win32_Foundation")]
9089 #[inline]
MsiSetFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, istate: INSTALLSTATE) -> u329090 pub unsafe fn MsiSetFeatureStateW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfeature: Param1, istate: INSTALLSTATE) -> u32 {
9091     #[cfg(windows)]
9092     {
9093         #[link(name = "windows")]
9094         extern "system" {
9095             fn MsiSetFeatureStateW(hinstall: MSIHANDLE, szfeature: super::super::Foundation::PWSTR, istate: INSTALLSTATE) -> u32;
9096         }
9097         ::std::mem::transmute(MsiSetFeatureStateW(hinstall.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(istate)))
9098     }
9099     #[cfg(not(windows))]
9100     unimplemented!("Unsupported target OS");
9101 }
9102 #[inline]
MsiSetInstallLevel<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, iinstalllevel: i32) -> u329103 pub unsafe fn MsiSetInstallLevel<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0, iinstalllevel: i32) -> u32 {
9104     #[cfg(windows)]
9105     {
9106         #[link(name = "windows")]
9107         extern "system" {
9108             fn MsiSetInstallLevel(hinstall: MSIHANDLE, iinstalllevel: i32) -> u32;
9109         }
9110         ::std::mem::transmute(MsiSetInstallLevel(hinstall.into_param().abi(), ::std::mem::transmute(iinstalllevel)))
9111     }
9112     #[cfg(not(windows))]
9113     unimplemented!("Unsupported target OS");
9114 }
9115 #[cfg(feature = "Win32_Foundation")]
9116 #[inline]
MsiSetInternalUI(dwuilevel: INSTALLUILEVEL, phwnd: *mut super::super::Foundation::HWND) -> INSTALLUILEVEL9117 pub unsafe fn MsiSetInternalUI(dwuilevel: INSTALLUILEVEL, phwnd: *mut super::super::Foundation::HWND) -> INSTALLUILEVEL {
9118     #[cfg(windows)]
9119     {
9120         #[link(name = "windows")]
9121         extern "system" {
9122             fn MsiSetInternalUI(dwuilevel: INSTALLUILEVEL, phwnd: *mut super::super::Foundation::HWND) -> INSTALLUILEVEL;
9123         }
9124         ::std::mem::transmute(MsiSetInternalUI(::std::mem::transmute(dwuilevel), ::std::mem::transmute(phwnd)))
9125     }
9126     #[cfg(not(windows))]
9127     unimplemented!("Unsupported target OS");
9128 }
9129 #[cfg(feature = "Win32_Foundation")]
9130 #[inline]
MsiSetMode<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hinstall: Param0, erunmode: MSIRUNMODE, fstate: Param2) -> u329131 pub unsafe fn MsiSetMode<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hinstall: Param0, erunmode: MSIRUNMODE, fstate: Param2) -> u32 {
9132     #[cfg(windows)]
9133     {
9134         #[link(name = "windows")]
9135         extern "system" {
9136             fn MsiSetMode(hinstall: MSIHANDLE, erunmode: MSIRUNMODE, fstate: super::super::Foundation::BOOL) -> u32;
9137         }
9138         ::std::mem::transmute(MsiSetMode(hinstall.into_param().abi(), ::std::mem::transmute(erunmode), fstate.into_param().abi()))
9139     }
9140     #[cfg(not(windows))]
9141     unimplemented!("Unsupported target OS");
9142 }
9143 #[cfg(feature = "Win32_Foundation")]
9144 #[inline]
MsiSetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szname: Param1, szvalue: Param2) -> u329145 pub unsafe fn MsiSetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szname: Param1, szvalue: Param2) -> u32 {
9146     #[cfg(windows)]
9147     {
9148         #[link(name = "windows")]
9149         extern "system" {
9150             fn MsiSetPropertyA(hinstall: MSIHANDLE, szname: super::super::Foundation::PSTR, szvalue: super::super::Foundation::PSTR) -> u32;
9151         }
9152         ::std::mem::transmute(MsiSetPropertyA(hinstall.into_param().abi(), szname.into_param().abi(), szvalue.into_param().abi()))
9153     }
9154     #[cfg(not(windows))]
9155     unimplemented!("Unsupported target OS");
9156 }
9157 #[cfg(feature = "Win32_Foundation")]
9158 #[inline]
MsiSetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szname: Param1, szvalue: Param2) -> u329159 pub unsafe fn MsiSetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szname: Param1, szvalue: Param2) -> u32 {
9160     #[cfg(windows)]
9161     {
9162         #[link(name = "windows")]
9163         extern "system" {
9164             fn MsiSetPropertyW(hinstall: MSIHANDLE, szname: super::super::Foundation::PWSTR, szvalue: super::super::Foundation::PWSTR) -> u32;
9165         }
9166         ::std::mem::transmute(MsiSetPropertyW(hinstall.into_param().abi(), szname.into_param().abi(), szvalue.into_param().abi()))
9167     }
9168     #[cfg(not(windows))]
9169     unimplemented!("Unsupported target OS");
9170 }
9171 #[cfg(feature = "Win32_Foundation")]
9172 #[inline]
MsiSetTargetPathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szfolderpath: Param2) -> u329173 pub unsafe fn MsiSetTargetPathA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hinstall: Param0, szfolder: Param1, szfolderpath: Param2) -> u32 {
9174     #[cfg(windows)]
9175     {
9176         #[link(name = "windows")]
9177         extern "system" {
9178             fn MsiSetTargetPathA(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PSTR, szfolderpath: super::super::Foundation::PSTR) -> u32;
9179         }
9180         ::std::mem::transmute(MsiSetTargetPathA(hinstall.into_param().abi(), szfolder.into_param().abi(), szfolderpath.into_param().abi()))
9181     }
9182     #[cfg(not(windows))]
9183     unimplemented!("Unsupported target OS");
9184 }
9185 #[cfg(feature = "Win32_Foundation")]
9186 #[inline]
MsiSetTargetPathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szfolderpath: Param2) -> u329187 pub unsafe fn MsiSetTargetPathW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hinstall: Param0, szfolder: Param1, szfolderpath: Param2) -> u32 {
9188     #[cfg(windows)]
9189     {
9190         #[link(name = "windows")]
9191         extern "system" {
9192             fn MsiSetTargetPathW(hinstall: MSIHANDLE, szfolder: super::super::Foundation::PWSTR, szfolderpath: super::super::Foundation::PWSTR) -> u32;
9193         }
9194         ::std::mem::transmute(MsiSetTargetPathW(hinstall.into_param().abi(), szfolder.into_param().abi(), szfolderpath.into_param().abi()))
9195     }
9196     #[cfg(not(windows))]
9197     unimplemented!("Unsupported target OS");
9198 }
9199 #[cfg(feature = "Win32_Foundation")]
9200 #[inline]
MsiSourceListAddMediaDiskA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32, szvolumelabel: Param5, szdiskprompt: Param6, ) -> u329201 pub unsafe fn MsiSourceListAddMediaDiskA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
9202     szproductcodeorpatchcode: Param0,
9203     szusersid: Param1,
9204     dwcontext: MSIINSTALLCONTEXT,
9205     dwoptions: u32,
9206     dwdiskid: u32,
9207     szvolumelabel: Param5,
9208     szdiskprompt: Param6,
9209 ) -> u32 {
9210     #[cfg(windows)]
9211     {
9212         #[link(name = "windows")]
9213         extern "system" {
9214             fn MsiSourceListAddMediaDiskA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32, szvolumelabel: super::super::Foundation::PSTR, szdiskprompt: super::super::Foundation::PSTR) -> u32;
9215         }
9216         ::std::mem::transmute(MsiSourceListAddMediaDiskA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwdiskid), szvolumelabel.into_param().abi(), szdiskprompt.into_param().abi()))
9217     }
9218     #[cfg(not(windows))]
9219     unimplemented!("Unsupported target OS");
9220 }
9221 #[cfg(feature = "Win32_Foundation")]
9222 #[inline]
MsiSourceListAddMediaDiskW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32, szvolumelabel: Param5, szdiskprompt: Param6, ) -> u329223 pub unsafe fn MsiSourceListAddMediaDiskW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
9224     szproductcodeorpatchcode: Param0,
9225     szusersid: Param1,
9226     dwcontext: MSIINSTALLCONTEXT,
9227     dwoptions: u32,
9228     dwdiskid: u32,
9229     szvolumelabel: Param5,
9230     szdiskprompt: Param6,
9231 ) -> u32 {
9232     #[cfg(windows)]
9233     {
9234         #[link(name = "windows")]
9235         extern "system" {
9236             fn MsiSourceListAddMediaDiskW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32, szvolumelabel: super::super::Foundation::PWSTR, szdiskprompt: super::super::Foundation::PWSTR) -> u32;
9237         }
9238         ::std::mem::transmute(MsiSourceListAddMediaDiskW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwdiskid), szvolumelabel.into_param().abi(), szdiskprompt.into_param().abi()))
9239     }
9240     #[cfg(not(windows))]
9241     unimplemented!("Unsupported target OS");
9242 }
9243 #[cfg(feature = "Win32_Foundation")]
9244 #[inline]
MsiSourceListAddSourceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32, szsource: Param3) -> u329245 pub unsafe fn MsiSourceListAddSourceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32, szsource: Param3) -> u32 {
9246     #[cfg(windows)]
9247     {
9248         #[link(name = "windows")]
9249         extern "system" {
9250             fn MsiSourceListAddSourceA(szproduct: super::super::Foundation::PSTR, szusername: super::super::Foundation::PSTR, dwreserved: u32, szsource: super::super::Foundation::PSTR) -> u32;
9251         }
9252         ::std::mem::transmute(MsiSourceListAddSourceA(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved), szsource.into_param().abi()))
9253     }
9254     #[cfg(not(windows))]
9255     unimplemented!("Unsupported target OS");
9256 }
9257 #[cfg(feature = "Win32_Foundation")]
9258 #[inline]
MsiSourceListAddSourceExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4, dwindex: u32) -> u329259 pub unsafe fn MsiSourceListAddSourceExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4, dwindex: u32) -> u32 {
9260     #[cfg(windows)]
9261     {
9262         #[link(name = "windows")]
9263         extern "system" {
9264             fn MsiSourceListAddSourceExA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: super::super::Foundation::PSTR, dwindex: u32) -> u32;
9265         }
9266         ::std::mem::transmute(MsiSourceListAddSourceExA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szsource.into_param().abi(), ::std::mem::transmute(dwindex)))
9267     }
9268     #[cfg(not(windows))]
9269     unimplemented!("Unsupported target OS");
9270 }
9271 #[cfg(feature = "Win32_Foundation")]
9272 #[inline]
MsiSourceListAddSourceExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4, dwindex: u32) -> u329273 pub unsafe fn MsiSourceListAddSourceExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4, dwindex: u32) -> u32 {
9274     #[cfg(windows)]
9275     {
9276         #[link(name = "windows")]
9277         extern "system" {
9278             fn MsiSourceListAddSourceExW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: super::super::Foundation::PWSTR, dwindex: u32) -> u32;
9279         }
9280         ::std::mem::transmute(MsiSourceListAddSourceExW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szsource.into_param().abi(), ::std::mem::transmute(dwindex)))
9281     }
9282     #[cfg(not(windows))]
9283     unimplemented!("Unsupported target OS");
9284 }
9285 #[cfg(feature = "Win32_Foundation")]
9286 #[inline]
MsiSourceListAddSourceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32, szsource: Param3) -> u329287 pub unsafe fn MsiSourceListAddSourceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32, szsource: Param3) -> u32 {
9288     #[cfg(windows)]
9289     {
9290         #[link(name = "windows")]
9291         extern "system" {
9292             fn MsiSourceListAddSourceW(szproduct: super::super::Foundation::PWSTR, szusername: super::super::Foundation::PWSTR, dwreserved: u32, szsource: super::super::Foundation::PWSTR) -> u32;
9293         }
9294         ::std::mem::transmute(MsiSourceListAddSourceW(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved), szsource.into_param().abi()))
9295     }
9296     #[cfg(not(windows))]
9297     unimplemented!("Unsupported target OS");
9298 }
9299 #[cfg(feature = "Win32_Foundation")]
9300 #[inline]
MsiSourceListClearAllA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u329301 pub unsafe fn MsiSourceListClearAllA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u32 {
9302     #[cfg(windows)]
9303     {
9304         #[link(name = "windows")]
9305         extern "system" {
9306             fn MsiSourceListClearAllA(szproduct: super::super::Foundation::PSTR, szusername: super::super::Foundation::PSTR, dwreserved: u32) -> u32;
9307         }
9308         ::std::mem::transmute(MsiSourceListClearAllA(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved)))
9309     }
9310     #[cfg(not(windows))]
9311     unimplemented!("Unsupported target OS");
9312 }
9313 #[cfg(feature = "Win32_Foundation")]
9314 #[inline]
MsiSourceListClearAllExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u329315 pub unsafe fn MsiSourceListClearAllExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32 {
9316     #[cfg(windows)]
9317     {
9318         #[link(name = "windows")]
9319         extern "system" {
9320             fn MsiSourceListClearAllExA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32;
9321         }
9322         ::std::mem::transmute(MsiSourceListClearAllExA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions)))
9323     }
9324     #[cfg(not(windows))]
9325     unimplemented!("Unsupported target OS");
9326 }
9327 #[cfg(feature = "Win32_Foundation")]
9328 #[inline]
MsiSourceListClearAllExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u329329 pub unsafe fn MsiSourceListClearAllExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32 {
9330     #[cfg(windows)]
9331     {
9332         #[link(name = "windows")]
9333         extern "system" {
9334             fn MsiSourceListClearAllExW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32;
9335         }
9336         ::std::mem::transmute(MsiSourceListClearAllExW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions)))
9337     }
9338     #[cfg(not(windows))]
9339     unimplemented!("Unsupported target OS");
9340 }
9341 #[cfg(feature = "Win32_Foundation")]
9342 #[inline]
MsiSourceListClearAllW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u329343 pub unsafe fn MsiSourceListClearAllW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u32 {
9344     #[cfg(windows)]
9345     {
9346         #[link(name = "windows")]
9347         extern "system" {
9348             fn MsiSourceListClearAllW(szproduct: super::super::Foundation::PWSTR, szusername: super::super::Foundation::PWSTR, dwreserved: u32) -> u32;
9349         }
9350         ::std::mem::transmute(MsiSourceListClearAllW(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved)))
9351     }
9352     #[cfg(not(windows))]
9353     unimplemented!("Unsupported target OS");
9354 }
9355 #[cfg(feature = "Win32_Foundation")]
9356 #[inline]
MsiSourceListClearMediaDiskA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u329357 pub unsafe fn MsiSourceListClearMediaDiskA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u32 {
9358     #[cfg(windows)]
9359     {
9360         #[link(name = "windows")]
9361         extern "system" {
9362             fn MsiSourceListClearMediaDiskA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u32;
9363         }
9364         ::std::mem::transmute(MsiSourceListClearMediaDiskA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwdiskid)))
9365     }
9366     #[cfg(not(windows))]
9367     unimplemented!("Unsupported target OS");
9368 }
9369 #[cfg(feature = "Win32_Foundation")]
9370 #[inline]
MsiSourceListClearMediaDiskW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u329371 pub unsafe fn MsiSourceListClearMediaDiskW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u32 {
9372     #[cfg(windows)]
9373     {
9374         #[link(name = "windows")]
9375         extern "system" {
9376             fn MsiSourceListClearMediaDiskW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwdiskid: u32) -> u32;
9377         }
9378         ::std::mem::transmute(MsiSourceListClearMediaDiskW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwdiskid)))
9379     }
9380     #[cfg(not(windows))]
9381     unimplemented!("Unsupported target OS");
9382 }
9383 #[cfg(feature = "Win32_Foundation")]
9384 #[inline]
MsiSourceListClearSourceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4) -> u329385 pub unsafe fn MsiSourceListClearSourceA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4) -> u32 {
9386     #[cfg(windows)]
9387     {
9388         #[link(name = "windows")]
9389         extern "system" {
9390             fn MsiSourceListClearSourceA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: super::super::Foundation::PSTR) -> u32;
9391         }
9392         ::std::mem::transmute(MsiSourceListClearSourceA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szsource.into_param().abi()))
9393     }
9394     #[cfg(not(windows))]
9395     unimplemented!("Unsupported target OS");
9396 }
9397 #[cfg(feature = "Win32_Foundation")]
9398 #[inline]
MsiSourceListClearSourceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4) -> u329399 pub unsafe fn MsiSourceListClearSourceW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: Param4) -> u32 {
9400     #[cfg(windows)]
9401     {
9402         #[link(name = "windows")]
9403         extern "system" {
9404             fn MsiSourceListClearSourceW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szsource: super::super::Foundation::PWSTR) -> u32;
9405         }
9406         ::std::mem::transmute(MsiSourceListClearSourceW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szsource.into_param().abi()))
9407     }
9408     #[cfg(not(windows))]
9409     unimplemented!("Unsupported target OS");
9410 }
9411 #[cfg(feature = "Win32_Foundation")]
9412 #[inline]
MsiSourceListEnumMediaDisksA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PSTR, pcchdiskprompt: *mut u32) -> u329413 pub unsafe fn MsiSourceListEnumMediaDisksA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PSTR, pcchdiskprompt: *mut u32) -> u32 {
9414     #[cfg(windows)]
9415     {
9416         #[link(name = "windows")]
9417         extern "system" {
9418             fn MsiSourceListEnumMediaDisksA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PSTR, pcchdiskprompt: *mut u32) -> u32;
9419         }
9420         ::std::mem::transmute(MsiSourceListEnumMediaDisksA(
9421             szproductcodeorpatchcode.into_param().abi(),
9422             szusersid.into_param().abi(),
9423             ::std::mem::transmute(dwcontext),
9424             ::std::mem::transmute(dwoptions),
9425             ::std::mem::transmute(dwindex),
9426             ::std::mem::transmute(pdwdiskid),
9427             ::std::mem::transmute(szvolumelabel),
9428             ::std::mem::transmute(pcchvolumelabel),
9429             ::std::mem::transmute(szdiskprompt),
9430             ::std::mem::transmute(pcchdiskprompt),
9431         ))
9432     }
9433     #[cfg(not(windows))]
9434     unimplemented!("Unsupported target OS");
9435 }
9436 #[cfg(feature = "Win32_Foundation")]
9437 #[inline]
MsiSourceListEnumMediaDisksW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PWSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PWSTR, pcchdiskprompt: *mut u32) -> u329438 pub unsafe fn MsiSourceListEnumMediaDisksW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PWSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PWSTR, pcchdiskprompt: *mut u32) -> u32 {
9439     #[cfg(windows)]
9440     {
9441         #[link(name = "windows")]
9442         extern "system" {
9443             fn MsiSourceListEnumMediaDisksW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, pdwdiskid: *mut u32, szvolumelabel: super::super::Foundation::PWSTR, pcchvolumelabel: *mut u32, szdiskprompt: super::super::Foundation::PWSTR, pcchdiskprompt: *mut u32) -> u32;
9444         }
9445         ::std::mem::transmute(MsiSourceListEnumMediaDisksW(
9446             szproductcodeorpatchcode.into_param().abi(),
9447             szusersid.into_param().abi(),
9448             ::std::mem::transmute(dwcontext),
9449             ::std::mem::transmute(dwoptions),
9450             ::std::mem::transmute(dwindex),
9451             ::std::mem::transmute(pdwdiskid),
9452             ::std::mem::transmute(szvolumelabel),
9453             ::std::mem::transmute(pcchvolumelabel),
9454             ::std::mem::transmute(szdiskprompt),
9455             ::std::mem::transmute(pcchdiskprompt),
9456         ))
9457     }
9458     #[cfg(not(windows))]
9459     unimplemented!("Unsupported target OS");
9460 }
9461 #[cfg(feature = "Win32_Foundation")]
9462 #[inline]
MsiSourceListEnumSourcesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PSTR, pcchsource: *mut u32) -> u329463 pub unsafe fn MsiSourceListEnumSourcesA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PSTR, pcchsource: *mut u32) -> u32 {
9464     #[cfg(windows)]
9465     {
9466         #[link(name = "windows")]
9467         extern "system" {
9468             fn MsiSourceListEnumSourcesA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PSTR, pcchsource: *mut u32) -> u32;
9469         }
9470         ::std::mem::transmute(MsiSourceListEnumSourcesA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwindex), ::std::mem::transmute(szsource), ::std::mem::transmute(pcchsource)))
9471     }
9472     #[cfg(not(windows))]
9473     unimplemented!("Unsupported target OS");
9474 }
9475 #[cfg(feature = "Win32_Foundation")]
9476 #[inline]
MsiSourceListEnumSourcesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PWSTR, pcchsource: *mut u32) -> u329477 pub unsafe fn MsiSourceListEnumSourcesW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PWSTR, pcchsource: *mut u32) -> u32 {
9478     #[cfg(windows)]
9479     {
9480         #[link(name = "windows")]
9481         extern "system" {
9482             fn MsiSourceListEnumSourcesW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, dwindex: u32, szsource: super::super::Foundation::PWSTR, pcchsource: *mut u32) -> u32;
9483         }
9484         ::std::mem::transmute(MsiSourceListEnumSourcesW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), ::std::mem::transmute(dwindex), ::std::mem::transmute(szsource), ::std::mem::transmute(pcchsource)))
9485     }
9486     #[cfg(not(windows))]
9487     unimplemented!("Unsupported target OS");
9488 }
9489 #[cfg(feature = "Win32_Foundation")]
9490 #[inline]
MsiSourceListForceResolutionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u329491 pub unsafe fn MsiSourceListForceResolutionA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u32 {
9492     #[cfg(windows)]
9493     {
9494         #[link(name = "windows")]
9495         extern "system" {
9496             fn MsiSourceListForceResolutionA(szproduct: super::super::Foundation::PSTR, szusername: super::super::Foundation::PSTR, dwreserved: u32) -> u32;
9497         }
9498         ::std::mem::transmute(MsiSourceListForceResolutionA(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved)))
9499     }
9500     #[cfg(not(windows))]
9501     unimplemented!("Unsupported target OS");
9502 }
9503 #[cfg(feature = "Win32_Foundation")]
9504 #[inline]
MsiSourceListForceResolutionExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u329505 pub unsafe fn MsiSourceListForceResolutionExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32 {
9506     #[cfg(windows)]
9507     {
9508         #[link(name = "windows")]
9509         extern "system" {
9510             fn MsiSourceListForceResolutionExA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32;
9511         }
9512         ::std::mem::transmute(MsiSourceListForceResolutionExA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions)))
9513     }
9514     #[cfg(not(windows))]
9515     unimplemented!("Unsupported target OS");
9516 }
9517 #[cfg(feature = "Win32_Foundation")]
9518 #[inline]
MsiSourceListForceResolutionExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u329519 pub unsafe fn MsiSourceListForceResolutionExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32 {
9520     #[cfg(windows)]
9521     {
9522         #[link(name = "windows")]
9523         extern "system" {
9524             fn MsiSourceListForceResolutionExW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32) -> u32;
9525         }
9526         ::std::mem::transmute(MsiSourceListForceResolutionExW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions)))
9527     }
9528     #[cfg(not(windows))]
9529     unimplemented!("Unsupported target OS");
9530 }
9531 #[cfg(feature = "Win32_Foundation")]
9532 #[inline]
MsiSourceListForceResolutionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u329533 pub unsafe fn MsiSourceListForceResolutionW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szusername: Param1, dwreserved: u32) -> u32 {
9534     #[cfg(windows)]
9535     {
9536         #[link(name = "windows")]
9537         extern "system" {
9538             fn MsiSourceListForceResolutionW(szproduct: super::super::Foundation::PWSTR, szusername: super::super::Foundation::PWSTR, dwreserved: u32) -> u32;
9539         }
9540         ::std::mem::transmute(MsiSourceListForceResolutionW(szproduct.into_param().abi(), szusername.into_param().abi(), ::std::mem::transmute(dwreserved)))
9541     }
9542     #[cfg(not(windows))]
9543     unimplemented!("Unsupported target OS");
9544 }
9545 #[cfg(feature = "Win32_Foundation")]
9546 #[inline]
MsiSourceListGetInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u329547 pub unsafe fn MsiSourceListGetInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u32 {
9548     #[cfg(windows)]
9549     {
9550         #[link(name = "windows")]
9551         extern "system" {
9552             fn MsiSourceListGetInfoA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: super::super::Foundation::PSTR, szvalue: super::super::Foundation::PSTR, pcchvalue: *mut u32) -> u32;
9553         }
9554         ::std::mem::transmute(MsiSourceListGetInfoA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szproperty.into_param().abi(), ::std::mem::transmute(szvalue), ::std::mem::transmute(pcchvalue)))
9555     }
9556     #[cfg(not(windows))]
9557     unimplemented!("Unsupported target OS");
9558 }
9559 #[cfg(feature = "Win32_Foundation")]
9560 #[inline]
MsiSourceListGetInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u329561 pub unsafe fn MsiSourceListGetInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u32 {
9562     #[cfg(windows)]
9563     {
9564         #[link(name = "windows")]
9565         extern "system" {
9566             fn MsiSourceListGetInfoW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: super::super::Foundation::PWSTR, szvalue: super::super::Foundation::PWSTR, pcchvalue: *mut u32) -> u32;
9567         }
9568         ::std::mem::transmute(MsiSourceListGetInfoW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szproperty.into_param().abi(), ::std::mem::transmute(szvalue), ::std::mem::transmute(pcchvalue)))
9569     }
9570     #[cfg(not(windows))]
9571     unimplemented!("Unsupported target OS");
9572 }
9573 #[cfg(feature = "Win32_Foundation")]
9574 #[inline]
MsiSourceListSetInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: Param5) -> u329575 pub unsafe fn MsiSourceListSetInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: Param5) -> u32 {
9576     #[cfg(windows)]
9577     {
9578         #[link(name = "windows")]
9579         extern "system" {
9580             fn MsiSourceListSetInfoA(szproductcodeorpatchcode: super::super::Foundation::PSTR, szusersid: super::super::Foundation::PSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: super::super::Foundation::PSTR, szvalue: super::super::Foundation::PSTR) -> u32;
9581         }
9582         ::std::mem::transmute(MsiSourceListSetInfoA(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szproperty.into_param().abi(), szvalue.into_param().abi()))
9583     }
9584     #[cfg(not(windows))]
9585     unimplemented!("Unsupported target OS");
9586 }
9587 #[cfg(feature = "Win32_Foundation")]
9588 #[inline]
MsiSourceListSetInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: Param5) -> u329589 pub unsafe fn MsiSourceListSetInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproductcodeorpatchcode: Param0, szusersid: Param1, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: Param4, szvalue: Param5) -> u32 {
9590     #[cfg(windows)]
9591     {
9592         #[link(name = "windows")]
9593         extern "system" {
9594             fn MsiSourceListSetInfoW(szproductcodeorpatchcode: super::super::Foundation::PWSTR, szusersid: super::super::Foundation::PWSTR, dwcontext: MSIINSTALLCONTEXT, dwoptions: u32, szproperty: super::super::Foundation::PWSTR, szvalue: super::super::Foundation::PWSTR) -> u32;
9595         }
9596         ::std::mem::transmute(MsiSourceListSetInfoW(szproductcodeorpatchcode.into_param().abi(), szusersid.into_param().abi(), ::std::mem::transmute(dwcontext), ::std::mem::transmute(dwoptions), szproperty.into_param().abi(), szvalue.into_param().abi()))
9597     }
9598     #[cfg(not(windows))]
9599     unimplemented!("Unsupported target OS");
9600 }
9601 #[cfg(feature = "Win32_Foundation")]
9602 #[inline]
MsiSummaryInfoGetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u329603 pub unsafe fn MsiSummaryInfoGetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32 {
9604     #[cfg(windows)]
9605     {
9606         #[link(name = "windows")]
9607         extern "system" {
9608             fn MsiSummaryInfoGetPropertyA(hsummaryinfo: MSIHANDLE, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PSTR, pcchvaluebuf: *mut u32) -> u32;
9609         }
9610         ::std::mem::transmute(MsiSummaryInfoGetPropertyA(hsummaryinfo.into_param().abi(), ::std::mem::transmute(uiproperty), ::std::mem::transmute(puidatatype), ::std::mem::transmute(pivalue), ::std::mem::transmute(pftvalue), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
9611     }
9612     #[cfg(not(windows))]
9613     unimplemented!("Unsupported target OS");
9614 }
9615 #[inline]
MsiSummaryInfoGetPropertyCount<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, puipropertycount: *mut u32) -> u329616 pub unsafe fn MsiSummaryInfoGetPropertyCount<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, puipropertycount: *mut u32) -> u32 {
9617     #[cfg(windows)]
9618     {
9619         #[link(name = "windows")]
9620         extern "system" {
9621             fn MsiSummaryInfoGetPropertyCount(hsummaryinfo: MSIHANDLE, puipropertycount: *mut u32) -> u32;
9622         }
9623         ::std::mem::transmute(MsiSummaryInfoGetPropertyCount(hsummaryinfo.into_param().abi(), ::std::mem::transmute(puipropertycount)))
9624     }
9625     #[cfg(not(windows))]
9626     unimplemented!("Unsupported target OS");
9627 }
9628 #[cfg(feature = "Win32_Foundation")]
9629 #[inline]
MsiSummaryInfoGetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u329630 pub unsafe fn MsiSummaryInfoGetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32 {
9631     #[cfg(windows)]
9632     {
9633         #[link(name = "windows")]
9634         extern "system" {
9635             fn MsiSummaryInfoGetPropertyW(hsummaryinfo: MSIHANDLE, uiproperty: u32, puidatatype: *mut u32, pivalue: *mut i32, pftvalue: *mut super::super::Foundation::FILETIME, szvaluebuf: super::super::Foundation::PWSTR, pcchvaluebuf: *mut u32) -> u32;
9636         }
9637         ::std::mem::transmute(MsiSummaryInfoGetPropertyW(hsummaryinfo.into_param().abi(), ::std::mem::transmute(uiproperty), ::std::mem::transmute(puidatatype), ::std::mem::transmute(pivalue), ::std::mem::transmute(pftvalue), ::std::mem::transmute(szvaluebuf), ::std::mem::transmute(pcchvaluebuf)))
9638     }
9639     #[cfg(not(windows))]
9640     unimplemented!("Unsupported target OS");
9641 }
9642 #[inline]
MsiSummaryInfoPersist<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0) -> u329643 pub unsafe fn MsiSummaryInfoPersist<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hsummaryinfo: Param0) -> u32 {
9644     #[cfg(windows)]
9645     {
9646         #[link(name = "windows")]
9647         extern "system" {
9648             fn MsiSummaryInfoPersist(hsummaryinfo: MSIHANDLE) -> u32;
9649         }
9650         ::std::mem::transmute(MsiSummaryInfoPersist(hsummaryinfo.into_param().abi()))
9651     }
9652     #[cfg(not(windows))]
9653     unimplemented!("Unsupported target OS");
9654 }
9655 #[cfg(feature = "Win32_Foundation")]
9656 #[inline]
MsiSummaryInfoSetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hsummaryinfo: Param0, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: Param5) -> u329657 pub unsafe fn MsiSummaryInfoSetPropertyA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hsummaryinfo: Param0, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: Param5) -> u32 {
9658     #[cfg(windows)]
9659     {
9660         #[link(name = "windows")]
9661         extern "system" {
9662             fn MsiSummaryInfoSetPropertyA(hsummaryinfo: MSIHANDLE, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: super::super::Foundation::PSTR) -> u32;
9663         }
9664         ::std::mem::transmute(MsiSummaryInfoSetPropertyA(hsummaryinfo.into_param().abi(), ::std::mem::transmute(uiproperty), ::std::mem::transmute(uidatatype), ::std::mem::transmute(ivalue), ::std::mem::transmute(pftvalue), szvalue.into_param().abi()))
9665     }
9666     #[cfg(not(windows))]
9667     unimplemented!("Unsupported target OS");
9668 }
9669 #[cfg(feature = "Win32_Foundation")]
9670 #[inline]
MsiSummaryInfoSetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsummaryinfo: Param0, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: Param5) -> u329671 pub unsafe fn MsiSummaryInfoSetPropertyW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsummaryinfo: Param0, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: Param5) -> u32 {
9672     #[cfg(windows)]
9673     {
9674         #[link(name = "windows")]
9675         extern "system" {
9676             fn MsiSummaryInfoSetPropertyW(hsummaryinfo: MSIHANDLE, uiproperty: u32, uidatatype: u32, ivalue: i32, pftvalue: *mut super::super::Foundation::FILETIME, szvalue: super::super::Foundation::PWSTR) -> u32;
9677         }
9678         ::std::mem::transmute(MsiSummaryInfoSetPropertyW(hsummaryinfo.into_param().abi(), ::std::mem::transmute(uiproperty), ::std::mem::transmute(uidatatype), ::std::mem::transmute(ivalue), ::std::mem::transmute(pftvalue), szvalue.into_param().abi()))
9679     }
9680     #[cfg(not(windows))]
9681     unimplemented!("Unsupported target OS");
9682 }
9683 #[cfg(feature = "Win32_Foundation")]
9684 #[inline]
MsiUseFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE9685 pub unsafe fn MsiUseFeatureA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE {
9686     #[cfg(windows)]
9687     {
9688         #[link(name = "windows")]
9689         extern "system" {
9690             fn MsiUseFeatureA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR) -> INSTALLSTATE;
9691         }
9692         ::std::mem::transmute(MsiUseFeatureA(szproduct.into_param().abi(), szfeature.into_param().abi()))
9693     }
9694     #[cfg(not(windows))]
9695     unimplemented!("Unsupported target OS");
9696 }
9697 #[cfg(feature = "Win32_Foundation")]
9698 #[inline]
MsiUseFeatureExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE9699 pub unsafe fn MsiUseFeatureExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szproduct: Param0, szfeature: Param1, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE {
9700     #[cfg(windows)]
9701     {
9702         #[link(name = "windows")]
9703         extern "system" {
9704             fn MsiUseFeatureExA(szproduct: super::super::Foundation::PSTR, szfeature: super::super::Foundation::PSTR, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE;
9705         }
9706         ::std::mem::transmute(MsiUseFeatureExA(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(dwreserved)))
9707     }
9708     #[cfg(not(windows))]
9709     unimplemented!("Unsupported target OS");
9710 }
9711 #[cfg(feature = "Win32_Foundation")]
9712 #[inline]
MsiUseFeatureExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE9713 pub unsafe fn MsiUseFeatureExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE {
9714     #[cfg(windows)]
9715     {
9716         #[link(name = "windows")]
9717         extern "system" {
9718             fn MsiUseFeatureExW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR, dwinstallmode: u32, dwreserved: u32) -> INSTALLSTATE;
9719         }
9720         ::std::mem::transmute(MsiUseFeatureExW(szproduct.into_param().abi(), szfeature.into_param().abi(), ::std::mem::transmute(dwinstallmode), ::std::mem::transmute(dwreserved)))
9721     }
9722     #[cfg(not(windows))]
9723     unimplemented!("Unsupported target OS");
9724 }
9725 #[cfg(feature = "Win32_Foundation")]
9726 #[inline]
MsiUseFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE9727 pub unsafe fn MsiUseFeatureW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szproduct: Param0, szfeature: Param1) -> INSTALLSTATE {
9728     #[cfg(windows)]
9729     {
9730         #[link(name = "windows")]
9731         extern "system" {
9732             fn MsiUseFeatureW(szproduct: super::super::Foundation::PWSTR, szfeature: super::super::Foundation::PWSTR) -> INSTALLSTATE;
9733         }
9734         ::std::mem::transmute(MsiUseFeatureW(szproduct.into_param().abi(), szfeature.into_param().abi()))
9735     }
9736     #[cfg(not(windows))]
9737     unimplemented!("Unsupported target OS");
9738 }
9739 #[inline]
MsiVerifyDiskSpace<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> u329740 pub unsafe fn MsiVerifyDiskSpace<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hinstall: Param0) -> u32 {
9741     #[cfg(windows)]
9742     {
9743         #[link(name = "windows")]
9744         extern "system" {
9745             fn MsiVerifyDiskSpace(hinstall: MSIHANDLE) -> u32;
9746         }
9747         ::std::mem::transmute(MsiVerifyDiskSpace(hinstall.into_param().abi()))
9748     }
9749     #[cfg(not(windows))]
9750     unimplemented!("Unsupported target OS");
9751 }
9752 #[cfg(feature = "Win32_Foundation")]
9753 #[inline]
MsiVerifyPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0) -> u329754 pub unsafe fn MsiVerifyPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szpackagepath: Param0) -> u32 {
9755     #[cfg(windows)]
9756     {
9757         #[link(name = "windows")]
9758         extern "system" {
9759             fn MsiVerifyPackageA(szpackagepath: super::super::Foundation::PSTR) -> u32;
9760         }
9761         ::std::mem::transmute(MsiVerifyPackageA(szpackagepath.into_param().abi()))
9762     }
9763     #[cfg(not(windows))]
9764     unimplemented!("Unsupported target OS");
9765 }
9766 #[cfg(feature = "Win32_Foundation")]
9767 #[inline]
MsiVerifyPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0) -> u329768 pub unsafe fn MsiVerifyPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szpackagepath: Param0) -> u32 {
9769     #[cfg(windows)]
9770     {
9771         #[link(name = "windows")]
9772         extern "system" {
9773             fn MsiVerifyPackageW(szpackagepath: super::super::Foundation::PWSTR) -> u32;
9774         }
9775         ::std::mem::transmute(MsiVerifyPackageW(szpackagepath.into_param().abi()))
9776     }
9777     #[cfg(not(windows))]
9778     unimplemented!("Unsupported target OS");
9779 }
9780 #[inline]
MsiViewClose<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0) -> u329781 pub unsafe fn MsiViewClose<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0) -> u32 {
9782     #[cfg(windows)]
9783     {
9784         #[link(name = "windows")]
9785         extern "system" {
9786             fn MsiViewClose(hview: MSIHANDLE) -> u32;
9787         }
9788         ::std::mem::transmute(MsiViewClose(hview.into_param().abi()))
9789     }
9790     #[cfg(not(windows))]
9791     unimplemented!("Unsupported target OS");
9792 }
9793 #[inline]
MsiViewExecute<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, hrecord: Param1) -> u329794 pub unsafe fn MsiViewExecute<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param1: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, hrecord: Param1) -> u32 {
9795     #[cfg(windows)]
9796     {
9797         #[link(name = "windows")]
9798         extern "system" {
9799             fn MsiViewExecute(hview: MSIHANDLE, hrecord: MSIHANDLE) -> u32;
9800         }
9801         ::std::mem::transmute(MsiViewExecute(hview.into_param().abi(), hrecord.into_param().abi()))
9802     }
9803     #[cfg(not(windows))]
9804     unimplemented!("Unsupported target OS");
9805 }
9806 #[inline]
MsiViewFetch<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, phrecord: *mut MSIHANDLE) -> u329807 pub unsafe fn MsiViewFetch<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, phrecord: *mut MSIHANDLE) -> u32 {
9808     #[cfg(windows)]
9809     {
9810         #[link(name = "windows")]
9811         extern "system" {
9812             fn MsiViewFetch(hview: MSIHANDLE, phrecord: *mut MSIHANDLE) -> u32;
9813         }
9814         ::std::mem::transmute(MsiViewFetch(hview.into_param().abi(), ::std::mem::transmute(phrecord)))
9815     }
9816     #[cfg(not(windows))]
9817     unimplemented!("Unsupported target OS");
9818 }
9819 #[inline]
MsiViewGetColumnInfo<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, ecolumninfo: MSICOLINFO, phrecord: *mut MSIHANDLE) -> u329820 pub unsafe fn MsiViewGetColumnInfo<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, ecolumninfo: MSICOLINFO, phrecord: *mut MSIHANDLE) -> u32 {
9821     #[cfg(windows)]
9822     {
9823         #[link(name = "windows")]
9824         extern "system" {
9825             fn MsiViewGetColumnInfo(hview: MSIHANDLE, ecolumninfo: MSICOLINFO, phrecord: *mut MSIHANDLE) -> u32;
9826         }
9827         ::std::mem::transmute(MsiViewGetColumnInfo(hview.into_param().abi(), ::std::mem::transmute(ecolumninfo), ::std::mem::transmute(phrecord)))
9828     }
9829     #[cfg(not(windows))]
9830     unimplemented!("Unsupported target OS");
9831 }
9832 #[cfg(feature = "Win32_Foundation")]
9833 #[inline]
MsiViewGetErrorA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, szcolumnnamebuffer: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> MSIDBERROR9834 pub unsafe fn MsiViewGetErrorA<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, szcolumnnamebuffer: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> MSIDBERROR {
9835     #[cfg(windows)]
9836     {
9837         #[link(name = "windows")]
9838         extern "system" {
9839             fn MsiViewGetErrorA(hview: MSIHANDLE, szcolumnnamebuffer: super::super::Foundation::PSTR, pcchbuf: *mut u32) -> MSIDBERROR;
9840         }
9841         ::std::mem::transmute(MsiViewGetErrorA(hview.into_param().abi(), ::std::mem::transmute(szcolumnnamebuffer), ::std::mem::transmute(pcchbuf)))
9842     }
9843     #[cfg(not(windows))]
9844     unimplemented!("Unsupported target OS");
9845 }
9846 #[cfg(feature = "Win32_Foundation")]
9847 #[inline]
MsiViewGetErrorW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, szcolumnnamebuffer: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> MSIDBERROR9848 pub unsafe fn MsiViewGetErrorW<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, szcolumnnamebuffer: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> MSIDBERROR {
9849     #[cfg(windows)]
9850     {
9851         #[link(name = "windows")]
9852         extern "system" {
9853             fn MsiViewGetErrorW(hview: MSIHANDLE, szcolumnnamebuffer: super::super::Foundation::PWSTR, pcchbuf: *mut u32) -> MSIDBERROR;
9854         }
9855         ::std::mem::transmute(MsiViewGetErrorW(hview.into_param().abi(), ::std::mem::transmute(szcolumnnamebuffer), ::std::mem::transmute(pcchbuf)))
9856     }
9857     #[cfg(not(windows))]
9858     unimplemented!("Unsupported target OS");
9859 }
9860 #[inline]
MsiViewModify<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, emodifymode: MSIMODIFY, hrecord: Param2) -> u329861 pub unsafe fn MsiViewModify<'a, Param0: ::windows::runtime::IntoParam<'a, MSIHANDLE>, Param2: ::windows::runtime::IntoParam<'a, MSIHANDLE>>(hview: Param0, emodifymode: MSIMODIFY, hrecord: Param2) -> u32 {
9862     #[cfg(windows)]
9863     {
9864         #[link(name = "windows")]
9865         extern "system" {
9866             fn MsiViewModify(hview: MSIHANDLE, emodifymode: MSIMODIFY, hrecord: MSIHANDLE) -> u32;
9867         }
9868         ::std::mem::transmute(MsiViewModify(hview.into_param().abi(), ::std::mem::transmute(emodifymode), hrecord.into_param().abi()))
9869     }
9870     #[cfg(not(windows))]
9871     unimplemented!("Unsupported target OS");
9872 }
9873 pub const MsmMerge: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(182298672, 11302, 4562, [173, 101, 0, 160, 201, 175, 17, 166]);
9874 #[cfg(feature = "Win32_Foundation")]
9875 #[inline]
NormalizeFileForPatchSignature(filebuffer: *mut ::std::ffi::c_void, filesize: u32, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, newfilecoffbase: u32, newfilecofftime: u32, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE) -> i329876 pub unsafe fn NormalizeFileForPatchSignature(filebuffer: *mut ::std::ffi::c_void, filesize: u32, optionflags: u32, optiondata: *const PATCH_OPTION_DATA, newfilecoffbase: u32, newfilecofftime: u32, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE) -> i32 {
9877     #[cfg(windows)]
9878     {
9879         #[link(name = "windows")]
9880         extern "system" {
9881             fn NormalizeFileForPatchSignature(filebuffer: *mut ::std::ffi::c_void, filesize: u32, optionflags: u32, optiondata: *const ::std::mem::ManuallyDrop<PATCH_OPTION_DATA>, newfilecoffbase: u32, newfilecofftime: u32, ignorerangecount: u32, ignorerangearray: *const PATCH_IGNORE_RANGE, retainrangecount: u32, retainrangearray: *const PATCH_RETAIN_RANGE) -> i32;
9882         }
9883         ::std::mem::transmute(NormalizeFileForPatchSignature(
9884             ::std::mem::transmute(filebuffer),
9885             ::std::mem::transmute(filesize),
9886             ::std::mem::transmute(optionflags),
9887             ::std::mem::transmute(optiondata),
9888             ::std::mem::transmute(newfilecoffbase),
9889             ::std::mem::transmute(newfilecofftime),
9890             ::std::mem::transmute(ignorerangecount),
9891             ::std::mem::transmute(ignorerangearray),
9892             ::std::mem::transmute(retainrangecount),
9893             ::std::mem::transmute(retainrangearray),
9894         ))
9895     }
9896     #[cfg(not(windows))]
9897     unimplemented!("Unsupported target OS");
9898 }
9899 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9900 #[repr(transparent)]
9901 pub struct PACKMAN_RUNTIME(pub i32);
9902 pub const PACKMAN_RUNTIME_NATIVE: PACKMAN_RUNTIME = PACKMAN_RUNTIME(1i32);
9903 pub const PACKMAN_RUNTIME_SILVERLIGHTMOBILE: PACKMAN_RUNTIME = PACKMAN_RUNTIME(2i32);
9904 pub const PACKMAN_RUNTIME_XNA: PACKMAN_RUNTIME = PACKMAN_RUNTIME(3i32);
9905 pub const PACKMAN_RUNTIME_MODERN_NATIVE: PACKMAN_RUNTIME = PACKMAN_RUNTIME(4i32);
9906 pub const PACKMAN_RUNTIME_JUPITER: PACKMAN_RUNTIME = PACKMAN_RUNTIME(5i32);
9907 pub const PACKMAN_RUNTIME_INVALID: PACKMAN_RUNTIME = PACKMAN_RUNTIME(6i32);
9908 impl ::std::convert::From<i32> for PACKMAN_RUNTIME {
from(value: i32) -> Self9909     fn from(value: i32) -> Self {
9910         Self(value)
9911     }
9912 }
9913 unsafe impl ::windows::runtime::Abi for PACKMAN_RUNTIME {
9914     type Abi = Self;
9915     type DefaultType = Self;
9916 }
9917 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9918 #[repr(C)]
9919 pub struct PATCH_IGNORE_RANGE {
9920     pub OffsetInOldFile: u32,
9921     pub LengthInBytes: u32,
9922 }
9923 impl PATCH_IGNORE_RANGE {}
9924 impl ::std::default::Default for PATCH_IGNORE_RANGE {
default() -> Self9925     fn default() -> Self {
9926         unsafe { ::std::mem::zeroed() }
9927     }
9928 }
9929 impl ::std::fmt::Debug for PATCH_IGNORE_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9930     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9931         fmt.debug_struct("PATCH_IGNORE_RANGE").field("OffsetInOldFile", &self.OffsetInOldFile).field("LengthInBytes", &self.LengthInBytes).finish()
9932     }
9933 }
9934 impl ::std::cmp::PartialEq for PATCH_IGNORE_RANGE {
eq(&self, other: &Self) -> bool9935     fn eq(&self, other: &Self) -> bool {
9936         self.OffsetInOldFile == other.OffsetInOldFile && self.LengthInBytes == other.LengthInBytes
9937     }
9938 }
9939 impl ::std::cmp::Eq for PATCH_IGNORE_RANGE {}
9940 unsafe impl ::windows::runtime::Abi for PATCH_IGNORE_RANGE {
9941     type Abi = Self;
9942     type DefaultType = Self;
9943 }
9944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9945 #[repr(C)]
9946 pub struct PATCH_INTERLEAVE_MAP {
9947     pub CountRanges: u32,
9948     pub Range: [PATCH_INTERLEAVE_MAP_0; 1],
9949 }
9950 impl PATCH_INTERLEAVE_MAP {}
9951 impl ::std::default::Default for PATCH_INTERLEAVE_MAP {
default() -> Self9952     fn default() -> Self {
9953         unsafe { ::std::mem::zeroed() }
9954     }
9955 }
9956 impl ::std::fmt::Debug for PATCH_INTERLEAVE_MAP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9957     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9958         fmt.debug_struct("PATCH_INTERLEAVE_MAP").field("CountRanges", &self.CountRanges).field("Range", &self.Range).finish()
9959     }
9960 }
9961 impl ::std::cmp::PartialEq for PATCH_INTERLEAVE_MAP {
eq(&self, other: &Self) -> bool9962     fn eq(&self, other: &Self) -> bool {
9963         self.CountRanges == other.CountRanges && self.Range == other.Range
9964     }
9965 }
9966 impl ::std::cmp::Eq for PATCH_INTERLEAVE_MAP {}
9967 unsafe impl ::windows::runtime::Abi for PATCH_INTERLEAVE_MAP {
9968     type Abi = Self;
9969     type DefaultType = Self;
9970 }
9971 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9972 #[repr(C)]
9973 pub struct PATCH_INTERLEAVE_MAP_0 {
9974     pub OldOffset: u32,
9975     pub OldLength: u32,
9976     pub NewLength: u32,
9977 }
9978 impl PATCH_INTERLEAVE_MAP_0 {}
9979 impl ::std::default::Default for PATCH_INTERLEAVE_MAP_0 {
default() -> Self9980     fn default() -> Self {
9981         unsafe { ::std::mem::zeroed() }
9982     }
9983 }
9984 impl ::std::fmt::Debug for PATCH_INTERLEAVE_MAP_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9985     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9986         fmt.debug_struct("_Anonymous_e__Struct").field("OldOffset", &self.OldOffset).field("OldLength", &self.OldLength).field("NewLength", &self.NewLength).finish()
9987     }
9988 }
9989 impl ::std::cmp::PartialEq for PATCH_INTERLEAVE_MAP_0 {
eq(&self, other: &Self) -> bool9990     fn eq(&self, other: &Self) -> bool {
9991         self.OldOffset == other.OldOffset && self.OldLength == other.OldLength && self.NewLength == other.NewLength
9992     }
9993 }
9994 impl ::std::cmp::Eq for PATCH_INTERLEAVE_MAP_0 {}
9995 unsafe impl ::windows::runtime::Abi for PATCH_INTERLEAVE_MAP_0 {
9996     type Abi = Self;
9997     type DefaultType = Self;
9998 }
9999 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10000 #[repr(C)]
10001 #[cfg(feature = "Win32_Foundation")]
10002 pub struct PATCH_OLD_FILE_INFO {
10003     pub SizeOfThisStruct: u32,
10004     pub Anonymous: PATCH_OLD_FILE_INFO_0,
10005     pub IgnoreRangeCount: u32,
10006     pub IgnoreRangeArray: *mut PATCH_IGNORE_RANGE,
10007     pub RetainRangeCount: u32,
10008     pub RetainRangeArray: *mut PATCH_RETAIN_RANGE,
10009 }
10010 #[cfg(feature = "Win32_Foundation")]
10011 impl PATCH_OLD_FILE_INFO {}
10012 #[cfg(feature = "Win32_Foundation")]
10013 impl ::std::default::Default for PATCH_OLD_FILE_INFO {
default() -> Self10014     fn default() -> Self {
10015         unsafe { ::std::mem::zeroed() }
10016     }
10017 }
10018 #[cfg(feature = "Win32_Foundation")]
10019 impl ::std::cmp::PartialEq for PATCH_OLD_FILE_INFO {
eq(&self, _other: &Self) -> bool10020     fn eq(&self, _other: &Self) -> bool {
10021         unimplemented!()
10022     }
10023 }
10024 #[cfg(feature = "Win32_Foundation")]
10025 impl ::std::cmp::Eq for PATCH_OLD_FILE_INFO {}
10026 #[cfg(feature = "Win32_Foundation")]
10027 unsafe impl ::windows::runtime::Abi for PATCH_OLD_FILE_INFO {
10028     type Abi = Self;
10029     type DefaultType = Self;
10030 }
10031 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10032 #[repr(C)]
10033 #[cfg(feature = "Win32_Foundation")]
10034 pub union PATCH_OLD_FILE_INFO_0 {
10035     pub OldFileNameA: super::super::Foundation::PSTR,
10036     pub OldFileNameW: super::super::Foundation::PWSTR,
10037     pub OldFileHandle: super::super::Foundation::HANDLE,
10038 }
10039 #[cfg(feature = "Win32_Foundation")]
10040 impl PATCH_OLD_FILE_INFO_0 {}
10041 #[cfg(feature = "Win32_Foundation")]
10042 impl ::std::default::Default for PATCH_OLD_FILE_INFO_0 {
default() -> Self10043     fn default() -> Self {
10044         unsafe { ::std::mem::zeroed() }
10045     }
10046 }
10047 #[cfg(feature = "Win32_Foundation")]
10048 impl ::std::cmp::PartialEq for PATCH_OLD_FILE_INFO_0 {
eq(&self, _other: &Self) -> bool10049     fn eq(&self, _other: &Self) -> bool {
10050         unimplemented!()
10051     }
10052 }
10053 #[cfg(feature = "Win32_Foundation")]
10054 impl ::std::cmp::Eq for PATCH_OLD_FILE_INFO_0 {}
10055 #[cfg(feature = "Win32_Foundation")]
10056 unsafe impl ::windows::runtime::Abi for PATCH_OLD_FILE_INFO_0 {
10057     type Abi = Self;
10058     type DefaultType = Self;
10059 }
10060 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10061 #[repr(C)]
10062 #[cfg(feature = "Win32_Foundation")]
10063 pub struct PATCH_OLD_FILE_INFO_A {
10064     pub SizeOfThisStruct: u32,
10065     pub OldFileName: super::super::Foundation::PSTR,
10066     pub IgnoreRangeCount: u32,
10067     pub IgnoreRangeArray: *mut PATCH_IGNORE_RANGE,
10068     pub RetainRangeCount: u32,
10069     pub RetainRangeArray: *mut PATCH_RETAIN_RANGE,
10070 }
10071 #[cfg(feature = "Win32_Foundation")]
10072 impl PATCH_OLD_FILE_INFO_A {}
10073 #[cfg(feature = "Win32_Foundation")]
10074 impl ::std::default::Default for PATCH_OLD_FILE_INFO_A {
default() -> Self10075     fn default() -> Self {
10076         unsafe { ::std::mem::zeroed() }
10077     }
10078 }
10079 #[cfg(feature = "Win32_Foundation")]
10080 impl ::std::fmt::Debug for PATCH_OLD_FILE_INFO_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10081     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10082         fmt.debug_struct("PATCH_OLD_FILE_INFO_A")
10083             .field("SizeOfThisStruct", &self.SizeOfThisStruct)
10084             .field("OldFileName", &self.OldFileName)
10085             .field("IgnoreRangeCount", &self.IgnoreRangeCount)
10086             .field("IgnoreRangeArray", &self.IgnoreRangeArray)
10087             .field("RetainRangeCount", &self.RetainRangeCount)
10088             .field("RetainRangeArray", &self.RetainRangeArray)
10089             .finish()
10090     }
10091 }
10092 #[cfg(feature = "Win32_Foundation")]
10093 impl ::std::cmp::PartialEq for PATCH_OLD_FILE_INFO_A {
eq(&self, other: &Self) -> bool10094     fn eq(&self, other: &Self) -> bool {
10095         self.SizeOfThisStruct == other.SizeOfThisStruct && self.OldFileName == other.OldFileName && self.IgnoreRangeCount == other.IgnoreRangeCount && self.IgnoreRangeArray == other.IgnoreRangeArray && self.RetainRangeCount == other.RetainRangeCount && self.RetainRangeArray == other.RetainRangeArray
10096     }
10097 }
10098 #[cfg(feature = "Win32_Foundation")]
10099 impl ::std::cmp::Eq for PATCH_OLD_FILE_INFO_A {}
10100 #[cfg(feature = "Win32_Foundation")]
10101 unsafe impl ::windows::runtime::Abi for PATCH_OLD_FILE_INFO_A {
10102     type Abi = Self;
10103     type DefaultType = Self;
10104 }
10105 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10106 #[repr(C)]
10107 #[cfg(feature = "Win32_Foundation")]
10108 pub struct PATCH_OLD_FILE_INFO_H {
10109     pub SizeOfThisStruct: u32,
10110     pub OldFileHandle: super::super::Foundation::HANDLE,
10111     pub IgnoreRangeCount: u32,
10112     pub IgnoreRangeArray: *mut PATCH_IGNORE_RANGE,
10113     pub RetainRangeCount: u32,
10114     pub RetainRangeArray: *mut PATCH_RETAIN_RANGE,
10115 }
10116 #[cfg(feature = "Win32_Foundation")]
10117 impl PATCH_OLD_FILE_INFO_H {}
10118 #[cfg(feature = "Win32_Foundation")]
10119 impl ::std::default::Default for PATCH_OLD_FILE_INFO_H {
default() -> Self10120     fn default() -> Self {
10121         unsafe { ::std::mem::zeroed() }
10122     }
10123 }
10124 #[cfg(feature = "Win32_Foundation")]
10125 impl ::std::fmt::Debug for PATCH_OLD_FILE_INFO_H {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10126     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10127         fmt.debug_struct("PATCH_OLD_FILE_INFO_H")
10128             .field("SizeOfThisStruct", &self.SizeOfThisStruct)
10129             .field("OldFileHandle", &self.OldFileHandle)
10130             .field("IgnoreRangeCount", &self.IgnoreRangeCount)
10131             .field("IgnoreRangeArray", &self.IgnoreRangeArray)
10132             .field("RetainRangeCount", &self.RetainRangeCount)
10133             .field("RetainRangeArray", &self.RetainRangeArray)
10134             .finish()
10135     }
10136 }
10137 #[cfg(feature = "Win32_Foundation")]
10138 impl ::std::cmp::PartialEq for PATCH_OLD_FILE_INFO_H {
eq(&self, other: &Self) -> bool10139     fn eq(&self, other: &Self) -> bool {
10140         self.SizeOfThisStruct == other.SizeOfThisStruct && self.OldFileHandle == other.OldFileHandle && self.IgnoreRangeCount == other.IgnoreRangeCount && self.IgnoreRangeArray == other.IgnoreRangeArray && self.RetainRangeCount == other.RetainRangeCount && self.RetainRangeArray == other.RetainRangeArray
10141     }
10142 }
10143 #[cfg(feature = "Win32_Foundation")]
10144 impl ::std::cmp::Eq for PATCH_OLD_FILE_INFO_H {}
10145 #[cfg(feature = "Win32_Foundation")]
10146 unsafe impl ::windows::runtime::Abi for PATCH_OLD_FILE_INFO_H {
10147     type Abi = Self;
10148     type DefaultType = Self;
10149 }
10150 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10151 #[repr(C)]
10152 #[cfg(feature = "Win32_Foundation")]
10153 pub struct PATCH_OLD_FILE_INFO_W {
10154     pub SizeOfThisStruct: u32,
10155     pub OldFileName: super::super::Foundation::PWSTR,
10156     pub IgnoreRangeCount: u32,
10157     pub IgnoreRangeArray: *mut PATCH_IGNORE_RANGE,
10158     pub RetainRangeCount: u32,
10159     pub RetainRangeArray: *mut PATCH_RETAIN_RANGE,
10160 }
10161 #[cfg(feature = "Win32_Foundation")]
10162 impl PATCH_OLD_FILE_INFO_W {}
10163 #[cfg(feature = "Win32_Foundation")]
10164 impl ::std::default::Default for PATCH_OLD_FILE_INFO_W {
default() -> Self10165     fn default() -> Self {
10166         unsafe { ::std::mem::zeroed() }
10167     }
10168 }
10169 #[cfg(feature = "Win32_Foundation")]
10170 impl ::std::fmt::Debug for PATCH_OLD_FILE_INFO_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10171     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10172         fmt.debug_struct("PATCH_OLD_FILE_INFO_W")
10173             .field("SizeOfThisStruct", &self.SizeOfThisStruct)
10174             .field("OldFileName", &self.OldFileName)
10175             .field("IgnoreRangeCount", &self.IgnoreRangeCount)
10176             .field("IgnoreRangeArray", &self.IgnoreRangeArray)
10177             .field("RetainRangeCount", &self.RetainRangeCount)
10178             .field("RetainRangeArray", &self.RetainRangeArray)
10179             .finish()
10180     }
10181 }
10182 #[cfg(feature = "Win32_Foundation")]
10183 impl ::std::cmp::PartialEq for PATCH_OLD_FILE_INFO_W {
eq(&self, other: &Self) -> bool10184     fn eq(&self, other: &Self) -> bool {
10185         self.SizeOfThisStruct == other.SizeOfThisStruct && self.OldFileName == other.OldFileName && self.IgnoreRangeCount == other.IgnoreRangeCount && self.IgnoreRangeArray == other.IgnoreRangeArray && self.RetainRangeCount == other.RetainRangeCount && self.RetainRangeArray == other.RetainRangeArray
10186     }
10187 }
10188 #[cfg(feature = "Win32_Foundation")]
10189 impl ::std::cmp::Eq for PATCH_OLD_FILE_INFO_W {}
10190 #[cfg(feature = "Win32_Foundation")]
10191 unsafe impl ::windows::runtime::Abi for PATCH_OLD_FILE_INFO_W {
10192     type Abi = Self;
10193     type DefaultType = Self;
10194 }
10195 #[derive(:: std :: clone :: Clone)]
10196 #[repr(C)]
10197 #[cfg(feature = "Win32_Foundation")]
10198 pub struct PATCH_OPTION_DATA {
10199     pub SizeOfThisStruct: u32,
10200     pub SymbolOptionFlags: u32,
10201     pub NewFileSymbolPath: super::super::Foundation::PSTR,
10202     pub OldFileSymbolPathArray: *mut super::super::Foundation::PSTR,
10203     pub ExtendedOptionFlags: u32,
10204     pub SymLoadCallback: ::std::option::Option<PPATCH_SYMLOAD_CALLBACK>,
10205     pub SymLoadContext: *mut ::std::ffi::c_void,
10206     pub InterleaveMapArray: *mut *mut PATCH_INTERLEAVE_MAP,
10207     pub MaxLzxWindowSize: u32,
10208 }
10209 #[cfg(feature = "Win32_Foundation")]
10210 impl PATCH_OPTION_DATA {}
10211 #[cfg(feature = "Win32_Foundation")]
10212 impl ::std::default::Default for PATCH_OPTION_DATA {
default() -> Self10213     fn default() -> Self {
10214         unsafe { ::std::mem::zeroed() }
10215     }
10216 }
10217 #[cfg(feature = "Win32_Foundation")]
10218 impl ::std::fmt::Debug for PATCH_OPTION_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10219     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10220         fmt.debug_struct("PATCH_OPTION_DATA")
10221             .field("SizeOfThisStruct", &self.SizeOfThisStruct)
10222             .field("SymbolOptionFlags", &self.SymbolOptionFlags)
10223             .field("NewFileSymbolPath", &self.NewFileSymbolPath)
10224             .field("OldFileSymbolPathArray", &self.OldFileSymbolPathArray)
10225             .field("ExtendedOptionFlags", &self.ExtendedOptionFlags)
10226             .field("SymLoadContext", &self.SymLoadContext)
10227             .field("InterleaveMapArray", &self.InterleaveMapArray)
10228             .field("MaxLzxWindowSize", &self.MaxLzxWindowSize)
10229             .finish()
10230     }
10231 }
10232 #[cfg(feature = "Win32_Foundation")]
10233 impl ::std::cmp::PartialEq for PATCH_OPTION_DATA {
eq(&self, other: &Self) -> bool10234     fn eq(&self, other: &Self) -> bool {
10235         self.SizeOfThisStruct == other.SizeOfThisStruct
10236             && self.SymbolOptionFlags == other.SymbolOptionFlags
10237             && self.NewFileSymbolPath == other.NewFileSymbolPath
10238             && self.OldFileSymbolPathArray == other.OldFileSymbolPathArray
10239             && self.ExtendedOptionFlags == other.ExtendedOptionFlags
10240             && self.SymLoadCallback.map(|f| f as usize) == other.SymLoadCallback.map(|f| f as usize)
10241             && self.SymLoadContext == other.SymLoadContext
10242             && self.InterleaveMapArray == other.InterleaveMapArray
10243             && self.MaxLzxWindowSize == other.MaxLzxWindowSize
10244     }
10245 }
10246 #[cfg(feature = "Win32_Foundation")]
10247 impl ::std::cmp::Eq for PATCH_OPTION_DATA {}
10248 #[cfg(feature = "Win32_Foundation")]
10249 unsafe impl ::windows::runtime::Abi for PATCH_OPTION_DATA {
10250     type Abi = ::std::mem::ManuallyDrop<Self>;
10251     type DefaultType = Self;
10252 }
10253 pub const PATCH_OPTION_FAIL_IF_BIGGER: u32 = 1048576u32;
10254 pub const PATCH_OPTION_FAIL_IF_SAME_FILE: u32 = 524288u32;
10255 pub const PATCH_OPTION_INTERLEAVE_FILES: u32 = 1073741824u32;
10256 pub const PATCH_OPTION_NO_BINDFIX: u32 = 65536u32;
10257 pub const PATCH_OPTION_NO_CHECKSUM: u32 = 2097152u32;
10258 pub const PATCH_OPTION_NO_LOCKFIX: u32 = 131072u32;
10259 pub const PATCH_OPTION_NO_REBASE: u32 = 262144u32;
10260 pub const PATCH_OPTION_NO_RESTIMEFIX: u32 = 4194304u32;
10261 pub const PATCH_OPTION_NO_TIMESTAMP: u32 = 8388608u32;
10262 pub const PATCH_OPTION_RESERVED1: u32 = 2147483648u32;
10263 pub const PATCH_OPTION_SIGNATURE_MD5: u32 = 16777216u32;
10264 pub const PATCH_OPTION_USE_BEST: u32 = 0u32;
10265 pub const PATCH_OPTION_USE_LZX_A: u32 = 1u32;
10266 pub const PATCH_OPTION_USE_LZX_B: u32 = 2u32;
10267 pub const PATCH_OPTION_USE_LZX_BEST: u32 = 3u32;
10268 pub const PATCH_OPTION_USE_LZX_LARGE: u32 = 4u32;
10269 pub const PATCH_OPTION_VALID_FLAGS: u32 = 3237937159u32;
10270 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10271 #[repr(C)]
10272 pub struct PATCH_RETAIN_RANGE {
10273     pub OffsetInOldFile: u32,
10274     pub LengthInBytes: u32,
10275     pub OffsetInNewFile: u32,
10276 }
10277 impl PATCH_RETAIN_RANGE {}
10278 impl ::std::default::Default for PATCH_RETAIN_RANGE {
default() -> Self10279     fn default() -> Self {
10280         unsafe { ::std::mem::zeroed() }
10281     }
10282 }
10283 impl ::std::fmt::Debug for PATCH_RETAIN_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10284     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10285         fmt.debug_struct("PATCH_RETAIN_RANGE").field("OffsetInOldFile", &self.OffsetInOldFile).field("LengthInBytes", &self.LengthInBytes).field("OffsetInNewFile", &self.OffsetInNewFile).finish()
10286     }
10287 }
10288 impl ::std::cmp::PartialEq for PATCH_RETAIN_RANGE {
eq(&self, other: &Self) -> bool10289     fn eq(&self, other: &Self) -> bool {
10290         self.OffsetInOldFile == other.OffsetInOldFile && self.LengthInBytes == other.LengthInBytes && self.OffsetInNewFile == other.OffsetInNewFile
10291     }
10292 }
10293 impl ::std::cmp::Eq for PATCH_RETAIN_RANGE {}
10294 unsafe impl ::windows::runtime::Abi for PATCH_RETAIN_RANGE {
10295     type Abi = Self;
10296     type DefaultType = Self;
10297 }
10298 pub const PATCH_SYMBOL_NO_FAILURES: u32 = 2u32;
10299 pub const PATCH_SYMBOL_NO_IMAGEHLP: u32 = 1u32;
10300 pub const PATCH_SYMBOL_RESERVED1: u32 = 2147483648u32;
10301 pub const PATCH_SYMBOL_UNDECORATED_TOO: u32 = 4u32;
10302 pub const PATCH_TRANSFORM_PE_IRELOC_2: u32 = 512u32;
10303 pub const PATCH_TRANSFORM_PE_RESOURCE_2: u32 = 256u32;
10304 pub const PID_APPNAME: u32 = 18u32;
10305 pub const PID_AUTHOR: u32 = 4u32;
10306 pub const PID_CHARCOUNT: u32 = 16u32;
10307 pub const PID_COMMENTS: u32 = 6u32;
10308 pub const PID_CREATE_DTM: u32 = 12u32;
10309 pub const PID_EDITTIME: u32 = 10u32;
10310 pub const PID_KEYWORDS: u32 = 5u32;
10311 pub const PID_LASTAUTHOR: u32 = 8u32;
10312 pub const PID_LASTPRINTED: u32 = 11u32;
10313 pub const PID_LASTSAVE_DTM: u32 = 13u32;
10314 pub const PID_MSIRESTRICT: u32 = 16u32;
10315 pub const PID_MSISOURCE: u32 = 15u32;
10316 pub const PID_MSIVERSION: u32 = 14u32;
10317 pub const PID_PAGECOUNT: u32 = 14u32;
10318 pub const PID_REVNUMBER: u32 = 9u32;
10319 pub const PID_SUBJECT: u32 = 3u32;
10320 pub const PID_TEMPLATE: u32 = 7u32;
10321 pub const PID_THUMBNAIL: u32 = 17u32;
10322 pub const PID_TITLE: u32 = 2u32;
10323 pub const PID_WORDCOUNT: u32 = 15u32;
10324 pub type PINSTALLUI_HANDLER_RECORD = unsafe extern "system" fn(pvcontext: *mut ::std::ffi::c_void, imessagetype: u32, hrecord: MSIHANDLE) -> i32;
10325 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10326 #[repr(C)]
10327 pub struct PMSIHANDLE {
10328     pub m_h: MSIHANDLE,
10329 }
10330 impl PMSIHANDLE {}
10331 impl ::std::default::Default for PMSIHANDLE {
default() -> Self10332     fn default() -> Self {
10333         unsafe { ::std::mem::zeroed() }
10334     }
10335 }
10336 impl ::std::fmt::Debug for PMSIHANDLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10337     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10338         fmt.debug_struct("PMSIHANDLE").field("m_h", &self.m_h).finish()
10339     }
10340 }
10341 impl ::std::cmp::PartialEq for PMSIHANDLE {
eq(&self, other: &Self) -> bool10342     fn eq(&self, other: &Self) -> bool {
10343         self.m_h == other.m_h
10344     }
10345 }
10346 impl ::std::cmp::Eq for PMSIHANDLE {}
10347 unsafe impl ::windows::runtime::Abi for PMSIHANDLE {
10348     type Abi = Self;
10349     type DefaultType = Self;
10350 }
10351 pub const PMSvc: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3118797308, 58212, 18810, [161, 33, 183, 179, 97, 44, 237, 206]);
10352 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10353 #[repr(transparent)]
10354 pub struct PM_ACTIVATION_POLICY(pub i32);
10355 pub const PM_ACTIVATION_POLICY_RESUME: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(0i32);
10356 pub const PM_ACTIVATION_POLICY_RESUMESAMEPARAMS: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(1i32);
10357 pub const PM_ACTIVATION_POLICY_REPLACE: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(2i32);
10358 pub const PM_ACTIVATION_POLICY_REPLACESAMEPARAMS: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(3i32);
10359 pub const PM_ACTIVATION_POLICY_MULTISESSION: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(4i32);
10360 pub const PM_ACTIVATION_POLICY_REPLACE_IGNOREFOREGROUND: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(5i32);
10361 pub const PM_ACTIVATION_POLICY_UNKNOWN: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(6i32);
10362 pub const PM_ACTIVATION_POLICY_INVALID: PM_ACTIVATION_POLICY = PM_ACTIVATION_POLICY(7i32);
10363 impl ::std::convert::From<i32> for PM_ACTIVATION_POLICY {
from(value: i32) -> Self10364     fn from(value: i32) -> Self {
10365         Self(value)
10366     }
10367 }
10368 unsafe impl ::windows::runtime::Abi for PM_ACTIVATION_POLICY {
10369     type Abi = Self;
10370     type DefaultType = Self;
10371 }
10372 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10373 #[repr(transparent)]
10374 pub struct PM_APPLICATION_HUBTYPE(pub i32);
10375 pub const PM_APPLICATION_HUBTYPE_NONMUSIC: PM_APPLICATION_HUBTYPE = PM_APPLICATION_HUBTYPE(0i32);
10376 pub const PM_APPLICATION_HUBTYPE_MUSIC: PM_APPLICATION_HUBTYPE = PM_APPLICATION_HUBTYPE(1i32);
10377 pub const PM_APPLICATION_HUBTYPE_INVALID: PM_APPLICATION_HUBTYPE = PM_APPLICATION_HUBTYPE(2i32);
10378 impl ::std::convert::From<i32> for PM_APPLICATION_HUBTYPE {
from(value: i32) -> Self10379     fn from(value: i32) -> Self {
10380         Self(value)
10381     }
10382 }
10383 unsafe impl ::windows::runtime::Abi for PM_APPLICATION_HUBTYPE {
10384     type Abi = Self;
10385     type DefaultType = Self;
10386 }
10387 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10388 #[repr(transparent)]
10389 pub struct PM_APPLICATION_INSTALL_TYPE(pub i32);
10390 pub const PM_APPLICATION_INSTALL_NORMAL: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(0i32);
10391 pub const PM_APPLICATION_INSTALL_IN_ROM: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(1i32);
10392 pub const PM_APPLICATION_INSTALL_PA: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(2i32);
10393 pub const PM_APPLICATION_INSTALL_DEBUG: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(3i32);
10394 pub const PM_APPLICATION_INSTALL_ENTERPRISE: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(4i32);
10395 pub const PM_APPLICATION_INSTALL_INVALID: PM_APPLICATION_INSTALL_TYPE = PM_APPLICATION_INSTALL_TYPE(5i32);
10396 impl ::std::convert::From<i32> for PM_APPLICATION_INSTALL_TYPE {
from(value: i32) -> Self10397     fn from(value: i32) -> Self {
10398         Self(value)
10399     }
10400 }
10401 unsafe impl ::windows::runtime::Abi for PM_APPLICATION_INSTALL_TYPE {
10402     type Abi = Self;
10403     type DefaultType = Self;
10404 }
10405 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10406 #[repr(transparent)]
10407 pub struct PM_APPLICATION_STATE(pub i32);
10408 pub const PM_APPLICATION_STATE_MIN: PM_APPLICATION_STATE = PM_APPLICATION_STATE(0i32);
10409 pub const PM_APPLICATION_STATE_INSTALLED: PM_APPLICATION_STATE = PM_APPLICATION_STATE(1i32);
10410 pub const PM_APPLICATION_STATE_INSTALLING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(2i32);
10411 pub const PM_APPLICATION_STATE_UPDATING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(3i32);
10412 pub const PM_APPLICATION_STATE_UNINSTALLING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(4i32);
10413 pub const PM_APPLICATION_STATE_LICENSE_UPDATING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(5i32);
10414 pub const PM_APPLICATION_STATE_MOVING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(6i32);
10415 pub const PM_APPLICATION_STATE_DISABLED_SD_CARD: PM_APPLICATION_STATE = PM_APPLICATION_STATE(7i32);
10416 pub const PM_APPLICATION_STATE_DISABLED_ENTERPRISE: PM_APPLICATION_STATE = PM_APPLICATION_STATE(8i32);
10417 pub const PM_APPLICATION_STATE_DISABLED_BACKING_UP: PM_APPLICATION_STATE = PM_APPLICATION_STATE(9i32);
10418 pub const PM_APPLICATION_STATE_DISABLED_MDIL_BINDING: PM_APPLICATION_STATE = PM_APPLICATION_STATE(10i32);
10419 pub const PM_APPLICATION_STATE_MAX: PM_APPLICATION_STATE = PM_APPLICATION_STATE(10i32);
10420 pub const PM_APPLICATION_STATE_INVALID: PM_APPLICATION_STATE = PM_APPLICATION_STATE(11i32);
10421 impl ::std::convert::From<i32> for PM_APPLICATION_STATE {
from(value: i32) -> Self10422     fn from(value: i32) -> Self {
10423         Self(value)
10424     }
10425 }
10426 unsafe impl ::windows::runtime::Abi for PM_APPLICATION_STATE {
10427     type Abi = Self;
10428     type DefaultType = Self;
10429 }
10430 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10431 #[repr(transparent)]
10432 pub struct PM_APP_GENRE(pub i32);
10433 pub const PM_APP_GENRE_GAMES: PM_APP_GENRE = PM_APP_GENRE(0i32);
10434 pub const PM_APP_GENRE_OTHER: PM_APP_GENRE = PM_APP_GENRE(1i32);
10435 pub const PM_APP_GENRE_INVALID: PM_APP_GENRE = PM_APP_GENRE(2i32);
10436 impl ::std::convert::From<i32> for PM_APP_GENRE {
from(value: i32) -> Self10437     fn from(value: i32) -> Self {
10438         Self(value)
10439     }
10440 }
10441 unsafe impl ::windows::runtime::Abi for PM_APP_GENRE {
10442     type Abi = Self;
10443     type DefaultType = Self;
10444 }
10445 #[derive(:: std :: clone :: Clone)]
10446 #[repr(C)]
10447 #[cfg(feature = "Win32_Foundation")]
10448 pub struct PM_BSATASKID {
10449     pub ProductID: ::windows::runtime::GUID,
10450     pub TaskID: super::super::Foundation::BSTR,
10451 }
10452 #[cfg(feature = "Win32_Foundation")]
10453 impl PM_BSATASKID {}
10454 #[cfg(feature = "Win32_Foundation")]
10455 impl ::std::default::Default for PM_BSATASKID {
default() -> Self10456     fn default() -> Self {
10457         unsafe { ::std::mem::zeroed() }
10458     }
10459 }
10460 #[cfg(feature = "Win32_Foundation")]
10461 impl ::std::fmt::Debug for PM_BSATASKID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10462     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10463         fmt.debug_struct("PM_BSATASKID").field("ProductID", &self.ProductID).field("TaskID", &self.TaskID).finish()
10464     }
10465 }
10466 #[cfg(feature = "Win32_Foundation")]
10467 impl ::std::cmp::PartialEq for PM_BSATASKID {
eq(&self, other: &Self) -> bool10468     fn eq(&self, other: &Self) -> bool {
10469         self.ProductID == other.ProductID && self.TaskID == other.TaskID
10470     }
10471 }
10472 #[cfg(feature = "Win32_Foundation")]
10473 impl ::std::cmp::Eq for PM_BSATASKID {}
10474 #[cfg(feature = "Win32_Foundation")]
10475 unsafe impl ::windows::runtime::Abi for PM_BSATASKID {
10476     type Abi = ::std::mem::ManuallyDrop<Self>;
10477     type DefaultType = Self;
10478 }
10479 #[derive(:: std :: clone :: Clone)]
10480 #[repr(C)]
10481 #[cfg(feature = "Win32_Foundation")]
10482 pub struct PM_BWTASKID {
10483     pub ProductID: ::windows::runtime::GUID,
10484     pub TaskID: super::super::Foundation::BSTR,
10485 }
10486 #[cfg(feature = "Win32_Foundation")]
10487 impl PM_BWTASKID {}
10488 #[cfg(feature = "Win32_Foundation")]
10489 impl ::std::default::Default for PM_BWTASKID {
default() -> Self10490     fn default() -> Self {
10491         unsafe { ::std::mem::zeroed() }
10492     }
10493 }
10494 #[cfg(feature = "Win32_Foundation")]
10495 impl ::std::fmt::Debug for PM_BWTASKID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10496     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10497         fmt.debug_struct("PM_BWTASKID").field("ProductID", &self.ProductID).field("TaskID", &self.TaskID).finish()
10498     }
10499 }
10500 #[cfg(feature = "Win32_Foundation")]
10501 impl ::std::cmp::PartialEq for PM_BWTASKID {
eq(&self, other: &Self) -> bool10502     fn eq(&self, other: &Self) -> bool {
10503         self.ProductID == other.ProductID && self.TaskID == other.TaskID
10504     }
10505 }
10506 #[cfg(feature = "Win32_Foundation")]
10507 impl ::std::cmp::Eq for PM_BWTASKID {}
10508 #[cfg(feature = "Win32_Foundation")]
10509 unsafe impl ::windows::runtime::Abi for PM_BWTASKID {
10510     type Abi = ::std::mem::ManuallyDrop<Self>;
10511     type DefaultType = Self;
10512 }
10513 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10514 #[repr(transparent)]
10515 pub struct PM_ENUM_APP_FILTER(pub i32);
10516 pub const PM_APP_FILTER_ALL: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(0i32);
10517 pub const PM_APP_FILTER_VISIBLE: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(1i32);
10518 pub const PM_APP_FILTER_GENRE: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(2i32);
10519 pub const PM_APP_FILTER_NONGAMES: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(3i32);
10520 pub const PM_APP_FILTER_HUBTYPE: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(4i32);
10521 pub const PM_APP_FILTER_PINABLEONKIDZONE: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(5i32);
10522 pub const PM_APP_FILTER_ALL_INCLUDE_MODERN: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(6i32);
10523 pub const PM_APP_FILTER_FRAMEWORK: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(7i32);
10524 pub const PM_APP_FILTER_MAX: PM_ENUM_APP_FILTER = PM_ENUM_APP_FILTER(8i32);
10525 impl ::std::convert::From<i32> for PM_ENUM_APP_FILTER {
from(value: i32) -> Self10526     fn from(value: i32) -> Self {
10527         Self(value)
10528     }
10529 }
10530 unsafe impl ::windows::runtime::Abi for PM_ENUM_APP_FILTER {
10531     type Abi = Self;
10532     type DefaultType = Self;
10533 }
10534 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10535 #[repr(transparent)]
10536 pub struct PM_ENUM_BSA_FILTER(pub i32);
10537 pub const PM_ENUM_BSA_FILTER_ALL: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(26i32);
10538 pub const PM_ENUM_BSA_FILTER_BY_TASKID: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(27i32);
10539 pub const PM_ENUM_BSA_FILTER_BY_PRODUCTID: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(28i32);
10540 pub const PM_ENUM_BSA_FILTER_BY_PERIODIC: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(29i32);
10541 pub const PM_ENUM_BSA_FILTER_BY_ALL_LAUNCHONBOOT: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(30i32);
10542 pub const PM_ENUM_BSA_FILTER_MAX: PM_ENUM_BSA_FILTER = PM_ENUM_BSA_FILTER(31i32);
10543 impl ::std::convert::From<i32> for PM_ENUM_BSA_FILTER {
from(value: i32) -> Self10544     fn from(value: i32) -> Self {
10545         Self(value)
10546     }
10547 }
10548 unsafe impl ::windows::runtime::Abi for PM_ENUM_BSA_FILTER {
10549     type Abi = Self;
10550     type DefaultType = Self;
10551 }
10552 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10553 #[repr(transparent)]
10554 pub struct PM_ENUM_BW_FILTER(pub i32);
10555 pub const PM_ENUM_BW_FILTER_BOOTWORKER_ALL: PM_ENUM_BW_FILTER = PM_ENUM_BW_FILTER(31i32);
10556 pub const PM_ENUM_BW_FILTER_BY_TASKID: PM_ENUM_BW_FILTER = PM_ENUM_BW_FILTER(32i32);
10557 pub const PM_ENUM_BW_FILTER_MAX: PM_ENUM_BW_FILTER = PM_ENUM_BW_FILTER(33i32);
10558 impl ::std::convert::From<i32> for PM_ENUM_BW_FILTER {
from(value: i32) -> Self10559     fn from(value: i32) -> Self {
10560         Self(value)
10561     }
10562 }
10563 unsafe impl ::windows::runtime::Abi for PM_ENUM_BW_FILTER {
10564     type Abi = Self;
10565     type DefaultType = Self;
10566 }
10567 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10568 #[repr(transparent)]
10569 pub struct PM_ENUM_EXTENSION_FILTER(pub i32);
10570 pub const PM_ENUM_EXTENSION_FILTER_BY_CONSUMER: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(17i32);
10571 pub const PM_ENUM_EXTENSION_FILTER_APPCONNECT: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(17i32);
10572 pub const PM_ENUM_EXTENSION_FILTER_PROTOCOL_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(18i32);
10573 pub const PM_ENUM_EXTENSION_FILTER_FTASSOC_FILETYPE_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(19i32);
10574 pub const PM_ENUM_EXTENSION_FILTER_FTASSOC_CONTENTTYPE_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(20i32);
10575 pub const PM_ENUM_EXTENSION_FILTER_FTASSOC_APPLICATION_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(21i32);
10576 pub const PM_ENUM_EXTENSION_FILTER_SHARETARGET_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(22i32);
10577 pub const PM_ENUM_EXTENSION_FILTER_FILEOPENPICKER_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(23i32);
10578 pub const PM_ENUM_EXTENSION_FILTER_FILESAVEPICKER_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(24i32);
10579 pub const PM_ENUM_EXTENSION_FILTER_CACHEDFILEUPDATER_ALL: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(25i32);
10580 pub const PM_ENUM_EXTENSION_FILTER_MAX: PM_ENUM_EXTENSION_FILTER = PM_ENUM_EXTENSION_FILTER(26i32);
10581 impl ::std::convert::From<i32> for PM_ENUM_EXTENSION_FILTER {
from(value: i32) -> Self10582     fn from(value: i32) -> Self {
10583         Self(value)
10584     }
10585 }
10586 unsafe impl ::windows::runtime::Abi for PM_ENUM_EXTENSION_FILTER {
10587     type Abi = Self;
10588     type DefaultType = Self;
10589 }
10590 #[cfg(feature = "Win32_Foundation")]
10591 impl ::std::clone::Clone for PM_ENUM_FILTER {
clone(&self) -> Self10592     fn clone(&self) -> Self {
10593         unimplemented!()
10594     }
10595 }
10596 #[repr(C)]
10597 #[cfg(feature = "Win32_Foundation")]
10598 pub struct PM_ENUM_FILTER {
10599     pub FilterType: i32,
10600     pub FilterParameter: PM_ENUM_FILTER_0,
10601 }
10602 #[cfg(feature = "Win32_Foundation")]
10603 impl PM_ENUM_FILTER {}
10604 #[cfg(feature = "Win32_Foundation")]
10605 impl ::std::default::Default for PM_ENUM_FILTER {
default() -> Self10606     fn default() -> Self {
10607         unsafe { ::std::mem::zeroed() }
10608     }
10609 }
10610 #[cfg(feature = "Win32_Foundation")]
10611 impl ::std::cmp::PartialEq for PM_ENUM_FILTER {
eq(&self, _other: &Self) -> bool10612     fn eq(&self, _other: &Self) -> bool {
10613         unimplemented!()
10614     }
10615 }
10616 #[cfg(feature = "Win32_Foundation")]
10617 impl ::std::cmp::Eq for PM_ENUM_FILTER {}
10618 #[cfg(feature = "Win32_Foundation")]
10619 unsafe impl ::windows::runtime::Abi for PM_ENUM_FILTER {
10620     type Abi = ::std::mem::ManuallyDrop<Self>;
10621     type DefaultType = Self;
10622 }
10623 #[cfg(feature = "Win32_Foundation")]
10624 impl ::std::clone::Clone for PM_ENUM_FILTER_0 {
clone(&self) -> Self10625     fn clone(&self) -> Self {
10626         unimplemented!()
10627     }
10628 }
10629 #[repr(C)]
10630 #[cfg(feature = "Win32_Foundation")]
10631 pub union PM_ENUM_FILTER_0 {
10632     pub Dummy: i32,
10633     pub Genre: PM_APP_GENRE,
10634     pub AppHubType: PM_APPLICATION_HUBTYPE,
10635     pub HubType: PM_TILE_HUBTYPE,
10636     pub Tasktype: PM_TASK_TYPE,
10637     pub TaskProductID: ::windows::runtime::GUID,
10638     pub TileProductID: ::windows::runtime::GUID,
10639     pub AppTaskType: _tagAPPTASKTYPE,
10640     pub Consumer: ::std::mem::ManuallyDrop<PM_EXTENSIONCONSUMER>,
10641     pub BSATask: ::std::mem::ManuallyDrop<PM_BSATASKID>,
10642     pub BSAProductID: ::windows::runtime::GUID,
10643     pub BWTask: ::std::mem::ManuallyDrop<PM_BWTASKID>,
10644     pub ProtocolName: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>,
10645     pub FileType: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>,
10646     pub ContentType: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>,
10647     pub AppSupportedFileExtPID: ::windows::runtime::GUID,
10648     pub ShareTargetFileType: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>,
10649 }
10650 #[cfg(feature = "Win32_Foundation")]
10651 impl PM_ENUM_FILTER_0 {}
10652 #[cfg(feature = "Win32_Foundation")]
10653 impl ::std::default::Default for PM_ENUM_FILTER_0 {
default() -> Self10654     fn default() -> Self {
10655         unsafe { ::std::mem::zeroed() }
10656     }
10657 }
10658 #[cfg(feature = "Win32_Foundation")]
10659 impl ::std::cmp::PartialEq for PM_ENUM_FILTER_0 {
eq(&self, _other: &Self) -> bool10660     fn eq(&self, _other: &Self) -> bool {
10661         unimplemented!()
10662     }
10663 }
10664 #[cfg(feature = "Win32_Foundation")]
10665 impl ::std::cmp::Eq for PM_ENUM_FILTER_0 {}
10666 #[cfg(feature = "Win32_Foundation")]
10667 unsafe impl ::windows::runtime::Abi for PM_ENUM_FILTER_0 {
10668     type Abi = ::std::mem::ManuallyDrop<Self>;
10669     type DefaultType = Self;
10670 }
10671 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10672 #[repr(transparent)]
10673 pub struct PM_ENUM_TASK_FILTER(pub i32);
10674 pub const PM_TASK_FILTER_APP_ALL: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(12i32);
10675 pub const PM_TASK_FILTER_TASK_TYPE: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(13i32);
10676 pub const PM_TASK_FILTER_DEHYD_SUPRESSING: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(14i32);
10677 pub const PM_TASK_FILTER_APP_TASK_TYPE: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(15i32);
10678 pub const PM_TASK_FILTER_BGEXECUTION: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(16i32);
10679 pub const PM_TASK_FILTER_MAX: PM_ENUM_TASK_FILTER = PM_ENUM_TASK_FILTER(17i32);
10680 impl ::std::convert::From<i32> for PM_ENUM_TASK_FILTER {
from(value: i32) -> Self10681     fn from(value: i32) -> Self {
10682         Self(value)
10683     }
10684 }
10685 unsafe impl ::windows::runtime::Abi for PM_ENUM_TASK_FILTER {
10686     type Abi = Self;
10687     type DefaultType = Self;
10688 }
10689 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10690 #[repr(transparent)]
10691 pub struct PM_ENUM_TILE_FILTER(pub i32);
10692 pub const PM_TILE_FILTER_APPLIST: PM_ENUM_TILE_FILTER = PM_ENUM_TILE_FILTER(8i32);
10693 pub const PM_TILE_FILTER_PINNED: PM_ENUM_TILE_FILTER = PM_ENUM_TILE_FILTER(9i32);
10694 pub const PM_TILE_FILTER_HUBTYPE: PM_ENUM_TILE_FILTER = PM_ENUM_TILE_FILTER(10i32);
10695 pub const PM_TILE_FILTER_APP_ALL: PM_ENUM_TILE_FILTER = PM_ENUM_TILE_FILTER(11i32);
10696 pub const PM_TILE_FILTER_MAX: PM_ENUM_TILE_FILTER = PM_ENUM_TILE_FILTER(12i32);
10697 impl ::std::convert::From<i32> for PM_ENUM_TILE_FILTER {
from(value: i32) -> Self10698     fn from(value: i32) -> Self {
10699         Self(value)
10700     }
10701 }
10702 unsafe impl ::windows::runtime::Abi for PM_ENUM_TILE_FILTER {
10703     type Abi = Self;
10704     type DefaultType = Self;
10705 }
10706 #[derive(:: std :: clone :: Clone)]
10707 #[repr(C)]
10708 #[cfg(feature = "Win32_Foundation")]
10709 pub struct PM_EXTENSIONCONSUMER {
10710     pub ConsumerPID: ::windows::runtime::GUID,
10711     pub ExtensionID: super::super::Foundation::BSTR,
10712 }
10713 #[cfg(feature = "Win32_Foundation")]
10714 impl PM_EXTENSIONCONSUMER {}
10715 #[cfg(feature = "Win32_Foundation")]
10716 impl ::std::default::Default for PM_EXTENSIONCONSUMER {
default() -> Self10717     fn default() -> Self {
10718         unsafe { ::std::mem::zeroed() }
10719     }
10720 }
10721 #[cfg(feature = "Win32_Foundation")]
10722 impl ::std::fmt::Debug for PM_EXTENSIONCONSUMER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10723     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10724         fmt.debug_struct("PM_EXTENSIONCONSUMER").field("ConsumerPID", &self.ConsumerPID).field("ExtensionID", &self.ExtensionID).finish()
10725     }
10726 }
10727 #[cfg(feature = "Win32_Foundation")]
10728 impl ::std::cmp::PartialEq for PM_EXTENSIONCONSUMER {
eq(&self, other: &Self) -> bool10729     fn eq(&self, other: &Self) -> bool {
10730         self.ConsumerPID == other.ConsumerPID && self.ExtensionID == other.ExtensionID
10731     }
10732 }
10733 #[cfg(feature = "Win32_Foundation")]
10734 impl ::std::cmp::Eq for PM_EXTENSIONCONSUMER {}
10735 #[cfg(feature = "Win32_Foundation")]
10736 unsafe impl ::windows::runtime::Abi for PM_EXTENSIONCONSUMER {
10737     type Abi = ::std::mem::ManuallyDrop<Self>;
10738     type DefaultType = Self;
10739 }
10740 #[derive(:: std :: clone :: Clone)]
10741 #[repr(C)]
10742 #[cfg(feature = "Win32_Foundation")]
10743 pub struct PM_INSTALLINFO {
10744     pub ProductID: ::windows::runtime::GUID,
10745     pub PackagePath: super::super::Foundation::BSTR,
10746     pub InstanceID: ::windows::runtime::GUID,
10747     pub pbLicense: *mut u8,
10748     pub cbLicense: u32,
10749     pub IsUninstallDisabled: super::super::Foundation::BOOL,
10750     pub DeploymentOptions: u32,
10751     pub OfferID: ::windows::runtime::GUID,
10752     pub MarketplaceAppVersion: super::super::Foundation::BSTR,
10753 }
10754 #[cfg(feature = "Win32_Foundation")]
10755 impl PM_INSTALLINFO {}
10756 #[cfg(feature = "Win32_Foundation")]
10757 impl ::std::default::Default for PM_INSTALLINFO {
default() -> Self10758     fn default() -> Self {
10759         unsafe { ::std::mem::zeroed() }
10760     }
10761 }
10762 #[cfg(feature = "Win32_Foundation")]
10763 impl ::std::fmt::Debug for PM_INSTALLINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10764     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10765         fmt.debug_struct("PM_INSTALLINFO")
10766             .field("ProductID", &self.ProductID)
10767             .field("PackagePath", &self.PackagePath)
10768             .field("InstanceID", &self.InstanceID)
10769             .field("pbLicense", &self.pbLicense)
10770             .field("cbLicense", &self.cbLicense)
10771             .field("IsUninstallDisabled", &self.IsUninstallDisabled)
10772             .field("DeploymentOptions", &self.DeploymentOptions)
10773             .field("OfferID", &self.OfferID)
10774             .field("MarketplaceAppVersion", &self.MarketplaceAppVersion)
10775             .finish()
10776     }
10777 }
10778 #[cfg(feature = "Win32_Foundation")]
10779 impl ::std::cmp::PartialEq for PM_INSTALLINFO {
eq(&self, other: &Self) -> bool10780     fn eq(&self, other: &Self) -> bool {
10781         self.ProductID == other.ProductID && self.PackagePath == other.PackagePath && self.InstanceID == other.InstanceID && self.pbLicense == other.pbLicense && self.cbLicense == other.cbLicense && self.IsUninstallDisabled == other.IsUninstallDisabled && self.DeploymentOptions == other.DeploymentOptions && self.OfferID == other.OfferID && self.MarketplaceAppVersion == other.MarketplaceAppVersion
10782     }
10783 }
10784 #[cfg(feature = "Win32_Foundation")]
10785 impl ::std::cmp::Eq for PM_INSTALLINFO {}
10786 #[cfg(feature = "Win32_Foundation")]
10787 unsafe impl ::windows::runtime::Abi for PM_INSTALLINFO {
10788     type Abi = ::std::mem::ManuallyDrop<Self>;
10789     type DefaultType = Self;
10790 }
10791 #[derive(:: std :: clone :: Clone)]
10792 #[repr(C)]
10793 #[cfg(feature = "Win32_Foundation")]
10794 pub struct PM_INVOCATIONINFO {
10795     pub URIBaseOrAUMID: super::super::Foundation::BSTR,
10796     pub URIFragmentOrArgs: super::super::Foundation::BSTR,
10797 }
10798 #[cfg(feature = "Win32_Foundation")]
10799 impl PM_INVOCATIONINFO {}
10800 #[cfg(feature = "Win32_Foundation")]
10801 impl ::std::default::Default for PM_INVOCATIONINFO {
default() -> Self10802     fn default() -> Self {
10803         unsafe { ::std::mem::zeroed() }
10804     }
10805 }
10806 #[cfg(feature = "Win32_Foundation")]
10807 impl ::std::fmt::Debug for PM_INVOCATIONINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10808     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10809         fmt.debug_struct("PM_INVOCATIONINFO").field("URIBaseOrAUMID", &self.URIBaseOrAUMID).field("URIFragmentOrArgs", &self.URIFragmentOrArgs).finish()
10810     }
10811 }
10812 #[cfg(feature = "Win32_Foundation")]
10813 impl ::std::cmp::PartialEq for PM_INVOCATIONINFO {
eq(&self, other: &Self) -> bool10814     fn eq(&self, other: &Self) -> bool {
10815         self.URIBaseOrAUMID == other.URIBaseOrAUMID && self.URIFragmentOrArgs == other.URIFragmentOrArgs
10816     }
10817 }
10818 #[cfg(feature = "Win32_Foundation")]
10819 impl ::std::cmp::Eq for PM_INVOCATIONINFO {}
10820 #[cfg(feature = "Win32_Foundation")]
10821 unsafe impl ::windows::runtime::Abi for PM_INVOCATIONINFO {
10822     type Abi = ::std::mem::ManuallyDrop<Self>;
10823     type DefaultType = Self;
10824 }
10825 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10826 #[repr(transparent)]
10827 pub struct PM_LIVETILE_RECURRENCE_TYPE(pub i32);
10828 pub const PM_LIVETILE_RECURRENCE_TYPE_INSTANT: PM_LIVETILE_RECURRENCE_TYPE = PM_LIVETILE_RECURRENCE_TYPE(0i32);
10829 pub const PM_LIVETILE_RECURRENCE_TYPE_ONETIME: PM_LIVETILE_RECURRENCE_TYPE = PM_LIVETILE_RECURRENCE_TYPE(1i32);
10830 pub const PM_LIVETILE_RECURRENCE_TYPE_INTERVAL: PM_LIVETILE_RECURRENCE_TYPE = PM_LIVETILE_RECURRENCE_TYPE(2i32);
10831 pub const PM_LIVETILE_RECURRENCE_TYPE_MAX: PM_LIVETILE_RECURRENCE_TYPE = PM_LIVETILE_RECURRENCE_TYPE(2i32);
10832 impl ::std::convert::From<i32> for PM_LIVETILE_RECURRENCE_TYPE {
from(value: i32) -> Self10833     fn from(value: i32) -> Self {
10834         Self(value)
10835     }
10836 }
10837 unsafe impl ::windows::runtime::Abi for PM_LIVETILE_RECURRENCE_TYPE {
10838     type Abi = Self;
10839     type DefaultType = Self;
10840 }
10841 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10842 #[repr(transparent)]
10843 pub struct PM_LOGO_SIZE(pub i32);
10844 pub const PM_LOGO_SIZE_SMALL: PM_LOGO_SIZE = PM_LOGO_SIZE(0i32);
10845 pub const PM_LOGO_SIZE_MEDIUM: PM_LOGO_SIZE = PM_LOGO_SIZE(1i32);
10846 pub const PM_LOGO_SIZE_LARGE: PM_LOGO_SIZE = PM_LOGO_SIZE(2i32);
10847 pub const PM_LOGO_SIZE_INVALID: PM_LOGO_SIZE = PM_LOGO_SIZE(3i32);
10848 impl ::std::convert::From<i32> for PM_LOGO_SIZE {
from(value: i32) -> Self10849     fn from(value: i32) -> Self {
10850         Self(value)
10851     }
10852 }
10853 unsafe impl ::windows::runtime::Abi for PM_LOGO_SIZE {
10854     type Abi = Self;
10855     type DefaultType = Self;
10856 }
10857 #[derive(:: std :: clone :: Clone)]
10858 #[repr(C)]
10859 #[cfg(feature = "Win32_Foundation")]
10860 pub struct PM_STARTAPPBLOB {
10861     pub cbSize: u32,
10862     pub ProductID: ::windows::runtime::GUID,
10863     pub AppTitle: super::super::Foundation::BSTR,
10864     pub IconPath: super::super::Foundation::BSTR,
10865     pub IsUninstallable: super::super::Foundation::BOOL,
10866     pub AppInstallType: PM_APPLICATION_INSTALL_TYPE,
10867     pub InstanceID: ::windows::runtime::GUID,
10868     pub State: PM_APPLICATION_STATE,
10869     pub IsModern: super::super::Foundation::BOOL,
10870     pub IsModernLightUp: super::super::Foundation::BOOL,
10871     pub LightUpSupportMask: u16,
10872 }
10873 #[cfg(feature = "Win32_Foundation")]
10874 impl PM_STARTAPPBLOB {}
10875 #[cfg(feature = "Win32_Foundation")]
10876 impl ::std::default::Default for PM_STARTAPPBLOB {
default() -> Self10877     fn default() -> Self {
10878         unsafe { ::std::mem::zeroed() }
10879     }
10880 }
10881 #[cfg(feature = "Win32_Foundation")]
10882 impl ::std::fmt::Debug for PM_STARTAPPBLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10883     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10884         fmt.debug_struct("PM_STARTAPPBLOB")
10885             .field("cbSize", &self.cbSize)
10886             .field("ProductID", &self.ProductID)
10887             .field("AppTitle", &self.AppTitle)
10888             .field("IconPath", &self.IconPath)
10889             .field("IsUninstallable", &self.IsUninstallable)
10890             .field("AppInstallType", &self.AppInstallType)
10891             .field("InstanceID", &self.InstanceID)
10892             .field("State", &self.State)
10893             .field("IsModern", &self.IsModern)
10894             .field("IsModernLightUp", &self.IsModernLightUp)
10895             .field("LightUpSupportMask", &self.LightUpSupportMask)
10896             .finish()
10897     }
10898 }
10899 #[cfg(feature = "Win32_Foundation")]
10900 impl ::std::cmp::PartialEq for PM_STARTAPPBLOB {
eq(&self, other: &Self) -> bool10901     fn eq(&self, other: &Self) -> bool {
10902         self.cbSize == other.cbSize && self.ProductID == other.ProductID && self.AppTitle == other.AppTitle && self.IconPath == other.IconPath && self.IsUninstallable == other.IsUninstallable && self.AppInstallType == other.AppInstallType && self.InstanceID == other.InstanceID && self.State == other.State && self.IsModern == other.IsModern && self.IsModernLightUp == other.IsModernLightUp && self.LightUpSupportMask == other.LightUpSupportMask
10903     }
10904 }
10905 #[cfg(feature = "Win32_Foundation")]
10906 impl ::std::cmp::Eq for PM_STARTAPPBLOB {}
10907 #[cfg(feature = "Win32_Foundation")]
10908 unsafe impl ::windows::runtime::Abi for PM_STARTAPPBLOB {
10909     type Abi = ::std::mem::ManuallyDrop<Self>;
10910     type DefaultType = Self;
10911 }
10912 #[derive(:: std :: clone :: Clone)]
10913 #[repr(C)]
10914 #[cfg(feature = "Win32_Foundation")]
10915 pub struct PM_STARTTILEBLOB {
10916     pub cbSize: u32,
10917     pub ProductID: ::windows::runtime::GUID,
10918     pub TileID: super::super::Foundation::BSTR,
10919     pub TemplateType: TILE_TEMPLATE_TYPE,
10920     pub HubPosition: [u32; 32],
10921     pub HubVisibilityBitmask: u32,
10922     pub IsDefault: super::super::Foundation::BOOL,
10923     pub TileType: PM_STARTTILE_TYPE,
10924     pub pbPropBlob: *mut u8,
10925     pub cbPropBlob: u32,
10926     pub IsRestoring: super::super::Foundation::BOOL,
10927     pub IsModern: super::super::Foundation::BOOL,
10928     pub InvocationInfo: PM_INVOCATIONINFO,
10929 }
10930 #[cfg(feature = "Win32_Foundation")]
10931 impl PM_STARTTILEBLOB {}
10932 #[cfg(feature = "Win32_Foundation")]
10933 impl ::std::default::Default for PM_STARTTILEBLOB {
default() -> Self10934     fn default() -> Self {
10935         unsafe { ::std::mem::zeroed() }
10936     }
10937 }
10938 #[cfg(feature = "Win32_Foundation")]
10939 impl ::std::fmt::Debug for PM_STARTTILEBLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10940     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10941         fmt.debug_struct("PM_STARTTILEBLOB")
10942             .field("cbSize", &self.cbSize)
10943             .field("ProductID", &self.ProductID)
10944             .field("TileID", &self.TileID)
10945             .field("TemplateType", &self.TemplateType)
10946             .field("HubPosition", &self.HubPosition)
10947             .field("HubVisibilityBitmask", &self.HubVisibilityBitmask)
10948             .field("IsDefault", &self.IsDefault)
10949             .field("TileType", &self.TileType)
10950             .field("pbPropBlob", &self.pbPropBlob)
10951             .field("cbPropBlob", &self.cbPropBlob)
10952             .field("IsRestoring", &self.IsRestoring)
10953             .field("IsModern", &self.IsModern)
10954             .field("InvocationInfo", &self.InvocationInfo)
10955             .finish()
10956     }
10957 }
10958 #[cfg(feature = "Win32_Foundation")]
10959 impl ::std::cmp::PartialEq for PM_STARTTILEBLOB {
eq(&self, other: &Self) -> bool10960     fn eq(&self, other: &Self) -> bool {
10961         self.cbSize == other.cbSize
10962             && self.ProductID == other.ProductID
10963             && self.TileID == other.TileID
10964             && self.TemplateType == other.TemplateType
10965             && self.HubPosition == other.HubPosition
10966             && self.HubVisibilityBitmask == other.HubVisibilityBitmask
10967             && self.IsDefault == other.IsDefault
10968             && self.TileType == other.TileType
10969             && self.pbPropBlob == other.pbPropBlob
10970             && self.cbPropBlob == other.cbPropBlob
10971             && self.IsRestoring == other.IsRestoring
10972             && self.IsModern == other.IsModern
10973             && self.InvocationInfo == other.InvocationInfo
10974     }
10975 }
10976 #[cfg(feature = "Win32_Foundation")]
10977 impl ::std::cmp::Eq for PM_STARTTILEBLOB {}
10978 #[cfg(feature = "Win32_Foundation")]
10979 unsafe impl ::windows::runtime::Abi for PM_STARTTILEBLOB {
10980     type Abi = ::std::mem::ManuallyDrop<Self>;
10981     type DefaultType = Self;
10982 }
10983 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10984 #[repr(transparent)]
10985 pub struct PM_STARTTILE_TYPE(pub i32);
10986 pub const PM_STARTTILE_TYPE_PRIMARY: PM_STARTTILE_TYPE = PM_STARTTILE_TYPE(1i32);
10987 pub const PM_STARTTILE_TYPE_SECONDARY: PM_STARTTILE_TYPE = PM_STARTTILE_TYPE(2i32);
10988 pub const PM_STARTTILE_TYPE_APPLIST: PM_STARTTILE_TYPE = PM_STARTTILE_TYPE(3i32);
10989 pub const PM_STARTTILE_TYPE_APPLISTPRIMARY: PM_STARTTILE_TYPE = PM_STARTTILE_TYPE(4i32);
10990 pub const PM_STARTTILE_TYPE_INVALID: PM_STARTTILE_TYPE = PM_STARTTILE_TYPE(5i32);
10991 impl ::std::convert::From<i32> for PM_STARTTILE_TYPE {
from(value: i32) -> Self10992     fn from(value: i32) -> Self {
10993         Self(value)
10994     }
10995 }
10996 unsafe impl ::windows::runtime::Abi for PM_STARTTILE_TYPE {
10997     type Abi = Self;
10998     type DefaultType = Self;
10999 }
11000 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11001 #[repr(transparent)]
11002 pub struct PM_TASK_TRANSITION(pub i32);
11003 pub const PM_TASK_TRANSITION_DEFAULT: PM_TASK_TRANSITION = PM_TASK_TRANSITION(0i32);
11004 pub const PM_TASK_TRANSITION_NONE: PM_TASK_TRANSITION = PM_TASK_TRANSITION(1i32);
11005 pub const PM_TASK_TRANSITION_TURNSTILE: PM_TASK_TRANSITION = PM_TASK_TRANSITION(2i32);
11006 pub const PM_TASK_TRANSITION_SLIDE: PM_TASK_TRANSITION = PM_TASK_TRANSITION(3i32);
11007 pub const PM_TASK_TRANSITION_SWIVEL: PM_TASK_TRANSITION = PM_TASK_TRANSITION(4i32);
11008 pub const PM_TASK_TRANSITION_READERBOARD: PM_TASK_TRANSITION = PM_TASK_TRANSITION(5i32);
11009 pub const PM_TASK_TRANSITION_CUSTOM: PM_TASK_TRANSITION = PM_TASK_TRANSITION(6i32);
11010 pub const PM_TASK_TRANSITION_INVALID: PM_TASK_TRANSITION = PM_TASK_TRANSITION(7i32);
11011 impl ::std::convert::From<i32> for PM_TASK_TRANSITION {
from(value: i32) -> Self11012     fn from(value: i32) -> Self {
11013         Self(value)
11014     }
11015 }
11016 unsafe impl ::windows::runtime::Abi for PM_TASK_TRANSITION {
11017     type Abi = Self;
11018     type DefaultType = Self;
11019 }
11020 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11021 #[repr(transparent)]
11022 pub struct PM_TASK_TYPE(pub i32);
11023 pub const PM_TASK_TYPE_NORMAL: PM_TASK_TYPE = PM_TASK_TYPE(0i32);
11024 pub const PM_TASK_TYPE_DEFAULT: PM_TASK_TYPE = PM_TASK_TYPE(1i32);
11025 pub const PM_TASK_TYPE_SETTINGS: PM_TASK_TYPE = PM_TASK_TYPE(2i32);
11026 pub const PM_TASK_TYPE_BACKGROUNDSERVICEAGENT: PM_TASK_TYPE = PM_TASK_TYPE(3i32);
11027 pub const PM_TASK_TYPE_BACKGROUNDWORKER: PM_TASK_TYPE = PM_TASK_TYPE(4i32);
11028 pub const PM_TASK_TYPE_INVALID: PM_TASK_TYPE = PM_TASK_TYPE(5i32);
11029 impl ::std::convert::From<i32> for PM_TASK_TYPE {
from(value: i32) -> Self11030     fn from(value: i32) -> Self {
11031         Self(value)
11032     }
11033 }
11034 unsafe impl ::windows::runtime::Abi for PM_TASK_TYPE {
11035     type Abi = Self;
11036     type DefaultType = Self;
11037 }
11038 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11039 #[repr(transparent)]
11040 pub struct PM_TILE_HUBTYPE(pub i32);
11041 pub const PM_TILE_HUBTYPE_MUSIC: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(1i32);
11042 pub const PM_TILE_HUBTYPE_MOSETTINGS: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(268435456i32);
11043 pub const PM_TILE_HUBTYPE_GAMES: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(536870912i32);
11044 pub const PM_TILE_HUBTYPE_APPLIST: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(1073741824i32);
11045 pub const PM_TILE_HUBTYPE_STARTMENU: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(-2147483648i32);
11046 pub const PM_TILE_HUBTYPE_LOCKSCREEN: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(16777216i32);
11047 pub const PM_TILE_HUBTYPE_KIDZONE: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(33554432i32);
11048 pub const PM_TILE_HUBTYPE_CACHED: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(67108864i32);
11049 pub const PM_TILE_HUBTYPE_INVALID: PM_TILE_HUBTYPE = PM_TILE_HUBTYPE(67108865i32);
11050 impl ::std::convert::From<i32> for PM_TILE_HUBTYPE {
from(value: i32) -> Self11051     fn from(value: i32) -> Self {
11052         Self(value)
11053     }
11054 }
11055 unsafe impl ::windows::runtime::Abi for PM_TILE_HUBTYPE {
11056     type Abi = Self;
11057     type DefaultType = Self;
11058 }
11059 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11060 #[repr(transparent)]
11061 pub struct PM_TILE_SIZE(pub i32);
11062 pub const PM_TILE_SIZE_SMALL: PM_TILE_SIZE = PM_TILE_SIZE(0i32);
11063 pub const PM_TILE_SIZE_MEDIUM: PM_TILE_SIZE = PM_TILE_SIZE(1i32);
11064 pub const PM_TILE_SIZE_LARGE: PM_TILE_SIZE = PM_TILE_SIZE(2i32);
11065 pub const PM_TILE_SIZE_SQUARE310X310: PM_TILE_SIZE = PM_TILE_SIZE(3i32);
11066 pub const PM_TILE_SIZE_TALL150X310: PM_TILE_SIZE = PM_TILE_SIZE(4i32);
11067 pub const PM_TILE_SIZE_INVALID: PM_TILE_SIZE = PM_TILE_SIZE(5i32);
11068 impl ::std::convert::From<i32> for PM_TILE_SIZE {
from(value: i32) -> Self11069     fn from(value: i32) -> Self {
11070         Self(value)
11071     }
11072 }
11073 unsafe impl ::windows::runtime::Abi for PM_TILE_SIZE {
11074     type Abi = Self;
11075     type DefaultType = Self;
11076 }
11077 #[derive(:: std :: clone :: Clone)]
11078 #[repr(C)]
11079 #[cfg(feature = "Win32_Foundation")]
11080 pub struct PM_UPDATEINFO {
11081     pub ProductID: ::windows::runtime::GUID,
11082     pub PackagePath: super::super::Foundation::BSTR,
11083     pub InstanceID: ::windows::runtime::GUID,
11084     pub pbLicense: *mut u8,
11085     pub cbLicense: u32,
11086     pub MarketplaceAppVersion: super::super::Foundation::BSTR,
11087     pub DeploymentOptions: u32,
11088 }
11089 #[cfg(feature = "Win32_Foundation")]
11090 impl PM_UPDATEINFO {}
11091 #[cfg(feature = "Win32_Foundation")]
11092 impl ::std::default::Default for PM_UPDATEINFO {
default() -> Self11093     fn default() -> Self {
11094         unsafe { ::std::mem::zeroed() }
11095     }
11096 }
11097 #[cfg(feature = "Win32_Foundation")]
11098 impl ::std::fmt::Debug for PM_UPDATEINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11099     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11100         fmt.debug_struct("PM_UPDATEINFO")
11101             .field("ProductID", &self.ProductID)
11102             .field("PackagePath", &self.PackagePath)
11103             .field("InstanceID", &self.InstanceID)
11104             .field("pbLicense", &self.pbLicense)
11105             .field("cbLicense", &self.cbLicense)
11106             .field("MarketplaceAppVersion", &self.MarketplaceAppVersion)
11107             .field("DeploymentOptions", &self.DeploymentOptions)
11108             .finish()
11109     }
11110 }
11111 #[cfg(feature = "Win32_Foundation")]
11112 impl ::std::cmp::PartialEq for PM_UPDATEINFO {
eq(&self, other: &Self) -> bool11113     fn eq(&self, other: &Self) -> bool {
11114         self.ProductID == other.ProductID && self.PackagePath == other.PackagePath && self.InstanceID == other.InstanceID && self.pbLicense == other.pbLicense && self.cbLicense == other.cbLicense && self.MarketplaceAppVersion == other.MarketplaceAppVersion && self.DeploymentOptions == other.DeploymentOptions
11115     }
11116 }
11117 #[cfg(feature = "Win32_Foundation")]
11118 impl ::std::cmp::Eq for PM_UPDATEINFO {}
11119 #[cfg(feature = "Win32_Foundation")]
11120 unsafe impl ::windows::runtime::Abi for PM_UPDATEINFO {
11121     type Abi = ::std::mem::ManuallyDrop<Self>;
11122     type DefaultType = Self;
11123 }
11124 #[derive(:: std :: clone :: Clone)]
11125 #[repr(C)]
11126 #[cfg(feature = "Win32_Foundation")]
11127 pub struct PM_UPDATEINFO_LEGACY {
11128     pub ProductID: ::windows::runtime::GUID,
11129     pub PackagePath: super::super::Foundation::BSTR,
11130     pub InstanceID: ::windows::runtime::GUID,
11131     pub pbLicense: *mut u8,
11132     pub cbLicense: u32,
11133     pub MarketplaceAppVersion: super::super::Foundation::BSTR,
11134 }
11135 #[cfg(feature = "Win32_Foundation")]
11136 impl PM_UPDATEINFO_LEGACY {}
11137 #[cfg(feature = "Win32_Foundation")]
11138 impl ::std::default::Default for PM_UPDATEINFO_LEGACY {
default() -> Self11139     fn default() -> Self {
11140         unsafe { ::std::mem::zeroed() }
11141     }
11142 }
11143 #[cfg(feature = "Win32_Foundation")]
11144 impl ::std::fmt::Debug for PM_UPDATEINFO_LEGACY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11145     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11146         fmt.debug_struct("PM_UPDATEINFO_LEGACY").field("ProductID", &self.ProductID).field("PackagePath", &self.PackagePath).field("InstanceID", &self.InstanceID).field("pbLicense", &self.pbLicense).field("cbLicense", &self.cbLicense).field("MarketplaceAppVersion", &self.MarketplaceAppVersion).finish()
11147     }
11148 }
11149 #[cfg(feature = "Win32_Foundation")]
11150 impl ::std::cmp::PartialEq for PM_UPDATEINFO_LEGACY {
eq(&self, other: &Self) -> bool11151     fn eq(&self, other: &Self) -> bool {
11152         self.ProductID == other.ProductID && self.PackagePath == other.PackagePath && self.InstanceID == other.InstanceID && self.pbLicense == other.pbLicense && self.cbLicense == other.cbLicense && self.MarketplaceAppVersion == other.MarketplaceAppVersion
11153     }
11154 }
11155 #[cfg(feature = "Win32_Foundation")]
11156 impl ::std::cmp::Eq for PM_UPDATEINFO_LEGACY {}
11157 #[cfg(feature = "Win32_Foundation")]
11158 unsafe impl ::windows::runtime::Abi for PM_UPDATEINFO_LEGACY {
11159     type Abi = ::std::mem::ManuallyDrop<Self>;
11160     type DefaultType = Self;
11161 }
11162 #[cfg(feature = "Win32_Foundation")]
11163 pub type PPATCH_PROGRESS_CALLBACK = unsafe extern "system" fn(callbackcontext: *mut ::std::ffi::c_void, currentposition: u32, maximumposition: u32) -> super::super::Foundation::BOOL;
11164 #[cfg(feature = "Win32_Foundation")]
11165 pub type PPATCH_SYMLOAD_CALLBACK = unsafe extern "system" fn(whichfile: u32, symbolfilename: super::super::Foundation::PSTR, symtype: u32, symbolfilechecksum: u32, symbolfiletimedate: u32, imagefilechecksum: u32, imagefiletimedate: u32, callbackcontext: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
11166 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11167 #[repr(C)]
11168 pub struct PROTECTED_FILE_DATA {
11169     pub FileName: [u16; 260],
11170     pub FileNumber: u32,
11171 }
11172 impl PROTECTED_FILE_DATA {}
11173 impl ::std::default::Default for PROTECTED_FILE_DATA {
default() -> Self11174     fn default() -> Self {
11175         unsafe { ::std::mem::zeroed() }
11176     }
11177 }
11178 impl ::std::fmt::Debug for PROTECTED_FILE_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11179     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11180         fmt.debug_struct("PROTECTED_FILE_DATA").field("FileName", &self.FileName).field("FileNumber", &self.FileNumber).finish()
11181     }
11182 }
11183 impl ::std::cmp::PartialEq for PROTECTED_FILE_DATA {
eq(&self, other: &Self) -> bool11184     fn eq(&self, other: &Self) -> bool {
11185         self.FileName == other.FileName && self.FileNumber == other.FileNumber
11186     }
11187 }
11188 impl ::std::cmp::Eq for PROTECTED_FILE_DATA {}
11189 unsafe impl ::windows::runtime::Abi for PROTECTED_FILE_DATA {
11190     type Abi = Self;
11191     type DefaultType = Self;
11192 }
11193 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11194 #[repr(transparent)]
11195 pub struct QUERYASMINFO_FLAGS(pub u32);
11196 pub const QUERYASMINFO_FLAG_VALIDATE: QUERYASMINFO_FLAGS = QUERYASMINFO_FLAGS(1u32);
11197 impl ::std::convert::From<u32> for QUERYASMINFO_FLAGS {
from(value: u32) -> Self11198     fn from(value: u32) -> Self {
11199         Self(value)
11200     }
11201 }
11202 unsafe impl ::windows::runtime::Abi for QUERYASMINFO_FLAGS {
11203     type Abi = Self;
11204     type DefaultType = Self;
11205 }
11206 impl ::std::ops::BitOr for QUERYASMINFO_FLAGS {
11207     type Output = Self;
bitor(self, rhs: Self) -> Self11208     fn bitor(self, rhs: Self) -> Self {
11209         Self(self.0 | rhs.0)
11210     }
11211 }
11212 impl ::std::ops::BitAnd for QUERYASMINFO_FLAGS {
11213     type Output = Self;
bitand(self, rhs: Self) -> Self11214     fn bitand(self, rhs: Self) -> Self {
11215         Self(self.0 & rhs.0)
11216     }
11217 }
11218 impl ::std::ops::BitOrAssign for QUERYASMINFO_FLAGS {
bitor_assign(&mut self, rhs: Self)11219     fn bitor_assign(&mut self, rhs: Self) {
11220         self.0.bitor_assign(rhs.0)
11221     }
11222 }
11223 impl ::std::ops::BitAndAssign for QUERYASMINFO_FLAGS {
bitand_assign(&mut self, rhs: Self)11224     fn bitand_assign(&mut self, rhs: Self) {
11225         self.0.bitand_assign(rhs.0)
11226     }
11227 }
11228 impl ::std::ops::Not for QUERYASMINFO_FLAGS {
11229     type Output = Self;
not(self) -> Self11230     fn not(self) -> Self {
11231         Self(self.0.not())
11232     }
11233 }
11234 #[cfg(feature = "Win32_Foundation")]
11235 #[inline]
QueryActCtxSettingsW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, hactctx: Param1, settingsnamespace: Param2, settingname: Param3, pvbuffer: super::super::Foundation::PWSTR, dwbuffer: usize, pdwwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL11236 pub unsafe fn QueryActCtxSettingsW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, hactctx: Param1, settingsnamespace: Param2, settingname: Param3, pvbuffer: super::super::Foundation::PWSTR, dwbuffer: usize, pdwwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL {
11237     #[cfg(windows)]
11238     {
11239         #[link(name = "windows")]
11240         extern "system" {
11241             fn QueryActCtxSettingsW(dwflags: u32, hactctx: super::super::Foundation::HANDLE, settingsnamespace: super::super::Foundation::PWSTR, settingname: super::super::Foundation::PWSTR, pvbuffer: super::super::Foundation::PWSTR, dwbuffer: usize, pdwwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL;
11242         }
11243         ::std::mem::transmute(QueryActCtxSettingsW(::std::mem::transmute(dwflags), hactctx.into_param().abi(), settingsnamespace.into_param().abi(), settingname.into_param().abi(), ::std::mem::transmute(pvbuffer), ::std::mem::transmute(dwbuffer), ::std::mem::transmute(pdwwrittenorrequired)))
11244     }
11245     #[cfg(not(windows))]
11246     unimplemented!("Unsupported target OS");
11247 }
11248 #[cfg(feature = "Win32_Foundation")]
11249 #[inline]
QueryActCtxW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(dwflags: u32, hactctx: Param1, pvsubinstance: *const ::std::ffi::c_void, ulinfoclass: u32, pvbuffer: *mut ::std::ffi::c_void, cbbuffer: usize, pcbwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL11250 pub unsafe fn QueryActCtxW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(dwflags: u32, hactctx: Param1, pvsubinstance: *const ::std::ffi::c_void, ulinfoclass: u32, pvbuffer: *mut ::std::ffi::c_void, cbbuffer: usize, pcbwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL {
11251     #[cfg(windows)]
11252     {
11253         #[link(name = "windows")]
11254         extern "system" {
11255             fn QueryActCtxW(dwflags: u32, hactctx: super::super::Foundation::HANDLE, pvsubinstance: *const ::std::ffi::c_void, ulinfoclass: u32, pvbuffer: *mut ::std::ffi::c_void, cbbuffer: usize, pcbwrittenorrequired: *mut usize) -> super::super::Foundation::BOOL;
11256         }
11257         ::std::mem::transmute(QueryActCtxW(::std::mem::transmute(dwflags), hactctx.into_param().abi(), ::std::mem::transmute(pvsubinstance), ::std::mem::transmute(ulinfoclass), ::std::mem::transmute(pvbuffer), ::std::mem::transmute(cbbuffer), ::std::mem::transmute(pcbwrittenorrequired)))
11258     }
11259     #[cfg(not(windows))]
11260     unimplemented!("Unsupported target OS");
11261 }
11262 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11263 #[repr(transparent)]
11264 pub struct REINSTALLMODE(pub i32);
11265 pub const REINSTALLMODE_REPAIR: REINSTALLMODE = REINSTALLMODE(1i32);
11266 pub const REINSTALLMODE_FILEMISSING: REINSTALLMODE = REINSTALLMODE(2i32);
11267 pub const REINSTALLMODE_FILEOLDERVERSION: REINSTALLMODE = REINSTALLMODE(4i32);
11268 pub const REINSTALLMODE_FILEEQUALVERSION: REINSTALLMODE = REINSTALLMODE(8i32);
11269 pub const REINSTALLMODE_FILEEXACT: REINSTALLMODE = REINSTALLMODE(16i32);
11270 pub const REINSTALLMODE_FILEVERIFY: REINSTALLMODE = REINSTALLMODE(32i32);
11271 pub const REINSTALLMODE_FILEREPLACE: REINSTALLMODE = REINSTALLMODE(64i32);
11272 pub const REINSTALLMODE_MACHINEDATA: REINSTALLMODE = REINSTALLMODE(128i32);
11273 pub const REINSTALLMODE_USERDATA: REINSTALLMODE = REINSTALLMODE(256i32);
11274 pub const REINSTALLMODE_SHORTCUT: REINSTALLMODE = REINSTALLMODE(512i32);
11275 pub const REINSTALLMODE_PACKAGE: REINSTALLMODE = REINSTALLMODE(1024i32);
11276 impl ::std::convert::From<i32> for REINSTALLMODE {
from(value: i32) -> Self11277     fn from(value: i32) -> Self {
11278         Self(value)
11279     }
11280 }
11281 unsafe impl ::windows::runtime::Abi for REINSTALLMODE {
11282     type Abi = Self;
11283     type DefaultType = Self;
11284 }
11285 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11286 #[repr(transparent)]
11287 pub struct RESULTTYPES(pub i32);
11288 pub const ieUnknown: RESULTTYPES = RESULTTYPES(0i32);
11289 pub const ieError: RESULTTYPES = RESULTTYPES(1i32);
11290 pub const ieWarning: RESULTTYPES = RESULTTYPES(2i32);
11291 pub const ieInfo: RESULTTYPES = RESULTTYPES(3i32);
11292 impl ::std::convert::From<i32> for RESULTTYPES {
from(value: i32) -> Self11293     fn from(value: i32) -> Self {
11294         Self(value)
11295     }
11296 }
11297 unsafe impl ::windows::runtime::Abi for RESULTTYPES {
11298     type Abi = Self;
11299     type DefaultType = Self;
11300 }
11301 #[cfg(feature = "Win32_Foundation")]
11302 #[inline]
ReleaseActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0)11303 pub unsafe fn ReleaseActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0) {
11304     #[cfg(windows)]
11305     {
11306         #[link(name = "windows")]
11307         extern "system" {
11308             fn ReleaseActCtx(hactctx: super::super::Foundation::HANDLE);
11309         }
11310         ::std::mem::transmute(ReleaseActCtx(hactctx.into_param().abi()))
11311     }
11312     #[cfg(not(windows))]
11313     unimplemented!("Unsupported target OS");
11314 }
11315 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11316 #[repr(transparent)]
11317 pub struct SCRIPTFLAGS(pub i32);
11318 pub const SCRIPTFLAGS_CACHEINFO: SCRIPTFLAGS = SCRIPTFLAGS(1i32);
11319 pub const SCRIPTFLAGS_SHORTCUTS: SCRIPTFLAGS = SCRIPTFLAGS(4i32);
11320 pub const SCRIPTFLAGS_MACHINEASSIGN: SCRIPTFLAGS = SCRIPTFLAGS(8i32);
11321 pub const SCRIPTFLAGS_REGDATA_CNFGINFO: SCRIPTFLAGS = SCRIPTFLAGS(32i32);
11322 pub const SCRIPTFLAGS_VALIDATE_TRANSFORMS_LIST: SCRIPTFLAGS = SCRIPTFLAGS(64i32);
11323 pub const SCRIPTFLAGS_REGDATA_CLASSINFO: SCRIPTFLAGS = SCRIPTFLAGS(128i32);
11324 pub const SCRIPTFLAGS_REGDATA_EXTENSIONINFO: SCRIPTFLAGS = SCRIPTFLAGS(256i32);
11325 pub const SCRIPTFLAGS_REGDATA_APPINFO: SCRIPTFLAGS = SCRIPTFLAGS(384i32);
11326 pub const SCRIPTFLAGS_REGDATA: SCRIPTFLAGS = SCRIPTFLAGS(416i32);
11327 impl ::std::convert::From<i32> for SCRIPTFLAGS {
from(value: i32) -> Self11328     fn from(value: i32) -> Self {
11329         Self(value)
11330     }
11331 }
11332 unsafe impl ::windows::runtime::Abi for SCRIPTFLAGS {
11333     type Abi = Self;
11334     type DefaultType = Self;
11335 }
11336 pub const SFC_DISABLE_ASK: u32 = 1u32;
11337 pub const SFC_DISABLE_NOPOPUPS: u32 = 4u32;
11338 pub const SFC_DISABLE_NORMAL: u32 = 0u32;
11339 pub const SFC_DISABLE_ONCE: u32 = 2u32;
11340 pub const SFC_DISABLE_SETUP: u32 = 3u32;
11341 pub const SFC_QUOTA_DEFAULT: u32 = 50u32;
11342 pub const SFC_SCAN_ALWAYS: u32 = 1u32;
11343 pub const SFC_SCAN_IMMEDIATE: u32 = 3u32;
11344 pub const SFC_SCAN_NORMAL: u32 = 0u32;
11345 pub const SFC_SCAN_ONCE: u32 = 2u32;
11346 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11347 #[repr(transparent)]
11348 pub struct STATUSTYPES(pub i32);
11349 pub const ieStatusGetCUB: STATUSTYPES = STATUSTYPES(0i32);
11350 pub const ieStatusICECount: STATUSTYPES = STATUSTYPES(1i32);
11351 pub const ieStatusMerge: STATUSTYPES = STATUSTYPES(2i32);
11352 pub const ieStatusSummaryInfo: STATUSTYPES = STATUSTYPES(3i32);
11353 pub const ieStatusCreateEngine: STATUSTYPES = STATUSTYPES(4i32);
11354 pub const ieStatusStarting: STATUSTYPES = STATUSTYPES(5i32);
11355 pub const ieStatusRunICE: STATUSTYPES = STATUSTYPES(6i32);
11356 pub const ieStatusShutdown: STATUSTYPES = STATUSTYPES(7i32);
11357 pub const ieStatusSuccess: STATUSTYPES = STATUSTYPES(8i32);
11358 pub const ieStatusFail: STATUSTYPES = STATUSTYPES(9i32);
11359 pub const ieStatusCancel: STATUSTYPES = STATUSTYPES(10i32);
11360 impl ::std::convert::From<i32> for STATUSTYPES {
from(value: i32) -> Self11361     fn from(value: i32) -> Self {
11362         Self(value)
11363     }
11364 }
11365 unsafe impl ::windows::runtime::Abi for STATUSTYPES {
11366     type Abi = Self;
11367     type DefaultType = Self;
11368 }
11369 pub const STREAM_FORMAT_COMPLIB_MANIFEST: u32 = 1u32;
11370 pub const STREAM_FORMAT_COMPLIB_MODULE: u32 = 0u32;
11371 pub const STREAM_FORMAT_WIN32_MANIFEST: u32 = 4u32;
11372 pub const STREAM_FORMAT_WIN32_MODULE: u32 = 2u32;
11373 #[cfg(feature = "Win32_Foundation")]
11374 #[inline]
SfcGetNextProtectedFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(rpchandle: Param0, protfiledata: *mut PROTECTED_FILE_DATA) -> super::super::Foundation::BOOL11375 pub unsafe fn SfcGetNextProtectedFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(rpchandle: Param0, protfiledata: *mut PROTECTED_FILE_DATA) -> super::super::Foundation::BOOL {
11376     #[cfg(windows)]
11377     {
11378         #[link(name = "windows")]
11379         extern "system" {
11380             fn SfcGetNextProtectedFile(rpchandle: super::super::Foundation::HANDLE, protfiledata: *mut PROTECTED_FILE_DATA) -> super::super::Foundation::BOOL;
11381         }
11382         ::std::mem::transmute(SfcGetNextProtectedFile(rpchandle.into_param().abi(), ::std::mem::transmute(protfiledata)))
11383     }
11384     #[cfg(not(windows))]
11385     unimplemented!("Unsupported target OS");
11386 }
11387 #[cfg(feature = "Win32_Foundation")]
11388 #[inline]
SfcIsFileProtected<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(rpchandle: Param0, protfilename: Param1) -> super::super::Foundation::BOOL11389 pub unsafe fn SfcIsFileProtected<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(rpchandle: Param0, protfilename: Param1) -> super::super::Foundation::BOOL {
11390     #[cfg(windows)]
11391     {
11392         #[link(name = "windows")]
11393         extern "system" {
11394             fn SfcIsFileProtected(rpchandle: super::super::Foundation::HANDLE, protfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
11395         }
11396         ::std::mem::transmute(SfcIsFileProtected(rpchandle.into_param().abi(), protfilename.into_param().abi()))
11397     }
11398     #[cfg(not(windows))]
11399     unimplemented!("Unsupported target OS");
11400 }
11401 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
11402 #[inline]
SfcIsKeyProtected<'a, Param0: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(keyhandle: Param0, subkeyname: Param1, keysam: u32) -> super::super::Foundation::BOOL11403 pub unsafe fn SfcIsKeyProtected<'a, Param0: ::windows::runtime::IntoParam<'a, super::Registry::HKEY>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(keyhandle: Param0, subkeyname: Param1, keysam: u32) -> super::super::Foundation::BOOL {
11404     #[cfg(windows)]
11405     {
11406         #[link(name = "windows")]
11407         extern "system" {
11408             fn SfcIsKeyProtected(keyhandle: super::Registry::HKEY, subkeyname: super::super::Foundation::PWSTR, keysam: u32) -> super::super::Foundation::BOOL;
11409         }
11410         ::std::mem::transmute(SfcIsKeyProtected(keyhandle.into_param().abi(), subkeyname.into_param().abi(), ::std::mem::transmute(keysam)))
11411     }
11412     #[cfg(not(windows))]
11413     unimplemented!("Unsupported target OS");
11414 }
11415 #[cfg(feature = "Win32_Foundation")]
11416 #[inline]
SfpVerifyFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszfilename: Param0, pszerror: Param1, dwerrsize: u32) -> super::super::Foundation::BOOL11417 pub unsafe fn SfpVerifyFile<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszfilename: Param0, pszerror: Param1, dwerrsize: u32) -> super::super::Foundation::BOOL {
11418     #[cfg(windows)]
11419     {
11420         #[link(name = "windows")]
11421         extern "system" {
11422             fn SfpVerifyFile(pszfilename: super::super::Foundation::PSTR, pszerror: super::super::Foundation::PSTR, dwerrsize: u32) -> super::super::Foundation::BOOL;
11423         }
11424         ::std::mem::transmute(SfpVerifyFile(pszfilename.into_param().abi(), pszerror.into_param().abi(), ::std::mem::transmute(dwerrsize)))
11425     }
11426     #[cfg(not(windows))]
11427     unimplemented!("Unsupported target OS");
11428 }
11429 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11430 #[repr(transparent)]
11431 pub struct TILE_TEMPLATE_TYPE(pub i32);
11432 pub const TILE_TEMPLATE_INVALID: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(0i32);
11433 pub const TILE_TEMPLATE_FLIP: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(5i32);
11434 pub const TILE_TEMPLATE_DEEPLINK: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(13i32);
11435 pub const TILE_TEMPLATE_CYCLE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(14i32);
11436 pub const TILE_TEMPLATE_METROCOUNT: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(1i32);
11437 pub const TILE_TEMPLATE_AGILESTORE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(2i32);
11438 pub const TILE_TEMPLATE_GAMES: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(3i32);
11439 pub const TILE_TEMPLATE_CALENDAR: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(4i32);
11440 pub const TILE_TEMPLATE_MUSICVIDEO: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(7i32);
11441 pub const TILE_TEMPLATE_PEOPLE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(10i32);
11442 pub const TILE_TEMPLATE_CONTACT: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(11i32);
11443 pub const TILE_TEMPLATE_GROUP: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(12i32);
11444 pub const TILE_TEMPLATE_DEFAULT: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(15i32);
11445 pub const TILE_TEMPLATE_BADGE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(16i32);
11446 pub const TILE_TEMPLATE_BLOCK: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(17i32);
11447 pub const TILE_TEMPLATE_TEXT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(18i32);
11448 pub const TILE_TEMPLATE_TEXT02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(19i32);
11449 pub const TILE_TEMPLATE_TEXT03: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(20i32);
11450 pub const TILE_TEMPLATE_TEXT04: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(21i32);
11451 pub const TILE_TEMPLATE_TEXT05: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(22i32);
11452 pub const TILE_TEMPLATE_TEXT06: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(23i32);
11453 pub const TILE_TEMPLATE_TEXT07: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(24i32);
11454 pub const TILE_TEMPLATE_TEXT08: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(25i32);
11455 pub const TILE_TEMPLATE_TEXT09: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(26i32);
11456 pub const TILE_TEMPLATE_TEXT10: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(27i32);
11457 pub const TILE_TEMPLATE_TEXT11: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(28i32);
11458 pub const TILE_TEMPLATE_IMAGE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(29i32);
11459 pub const TILE_TEMPLATE_IMAGECOLLECTION: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(30i32);
11460 pub const TILE_TEMPLATE_IMAGEANDTEXT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(31i32);
11461 pub const TILE_TEMPLATE_IMAGEANDTEXT02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(32i32);
11462 pub const TILE_TEMPLATE_BLOCKANDTEXT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(33i32);
11463 pub const TILE_TEMPLATE_BLOCKANDTEXT02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(34i32);
11464 pub const TILE_TEMPLATE_PEEKIMAGEANDTEXT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(35i32);
11465 pub const TILE_TEMPLATE_PEEKIMAGEANDTEXT02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(36i32);
11466 pub const TILE_TEMPLATE_PEEKIMAGEANDTEXT03: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(37i32);
11467 pub const TILE_TEMPLATE_PEEKIMAGEANDTEXT04: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(38i32);
11468 pub const TILE_TEMPLATE_PEEKIMAGE01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(39i32);
11469 pub const TILE_TEMPLATE_PEEKIMAGE02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(40i32);
11470 pub const TILE_TEMPLATE_PEEKIMAGE03: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(41i32);
11471 pub const TILE_TEMPLATE_PEEKIMAGE04: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(42i32);
11472 pub const TILE_TEMPLATE_PEEKIMAGE05: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(43i32);
11473 pub const TILE_TEMPLATE_PEEKIMAGE06: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(44i32);
11474 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(45i32);
11475 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(46i32);
11476 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION03: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(47i32);
11477 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION04: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(48i32);
11478 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION05: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(49i32);
11479 pub const TILE_TEMPLATE_PEEKIMAGECOLLECTION06: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(50i32);
11480 pub const TILE_TEMPLATE_SMALLIMAGEANDTEXT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(51i32);
11481 pub const TILE_TEMPLATE_SMALLIMAGEANDTEXT02: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(52i32);
11482 pub const TILE_TEMPLATE_SMALLIMAGEANDTEXT03: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(53i32);
11483 pub const TILE_TEMPLATE_SMALLIMAGEANDTEXT04: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(54i32);
11484 pub const TILE_TEMPLATE_SMALLIMAGEANDTEXT05: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(55i32);
11485 pub const TILE_TEMPLATE_METROCOUNTQUEUE: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(56i32);
11486 pub const TILE_TEMPLATE_SEARCH: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(57i32);
11487 pub const TILE_TEMPLATE_TILEFLYOUT01: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(58i32);
11488 pub const TILE_TEMPLATE_FOLDER: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(59i32);
11489 pub const TILE_TEMPLATE_ALL: TILE_TEMPLATE_TYPE = TILE_TEMPLATE_TYPE(100i32);
11490 impl ::std::convert::From<i32> for TILE_TEMPLATE_TYPE {
from(value: i32) -> Self11491     fn from(value: i32) -> Self {
11492         Self(value)
11493     }
11494 }
11495 unsafe impl ::windows::runtime::Abi for TILE_TEMPLATE_TYPE {
11496     type Abi = Self;
11497     type DefaultType = Self;
11498 }
11499 pub const TXTLOG_BACKUP: u32 = 128u32;
11500 pub const TXTLOG_CMI: u32 = 268435456u32;
11501 pub const TXTLOG_COPYFILES: u32 = 8u32;
11502 pub const TXTLOG_DEPTH_DECR: u32 = 262144u32;
11503 pub const TXTLOG_DEPTH_INCR: u32 = 131072u32;
11504 pub const TXTLOG_DETAILS: u32 = 5u32;
11505 pub const TXTLOG_DEVINST: u32 = 1u32;
11506 pub const TXTLOG_DEVMGR: u32 = 536870912u32;
11507 pub const TXTLOG_DRIVER_STORE: u32 = 67108864u32;
11508 pub const TXTLOG_DRVSETUP: u32 = 4194304u32;
11509 pub const TXTLOG_ERROR: u32 = 1u32;
11510 pub const TXTLOG_FILEQ: u32 = 4u32;
11511 pub const TXTLOG_FLUSH_FILE: u32 = 1048576u32;
11512 pub const TXTLOG_INF: u32 = 2u32;
11513 pub const TXTLOG_INFDB: u32 = 1024u32;
11514 pub const TXTLOG_INSTALLER: u32 = 1073741824u32;
11515 pub const TXTLOG_NEWDEV: u32 = 16777216u32;
11516 pub const TXTLOG_POLICY: u32 = 8388608u32;
11517 pub const TXTLOG_RESERVED_FLAGS: u32 = 65520u32;
11518 pub const TXTLOG_SETUP: u32 = 134217728u32;
11519 pub const TXTLOG_SETUPAPI_BITS: u32 = 3u32;
11520 pub const TXTLOG_SETUPAPI_CMDLINE: u32 = 2u32;
11521 pub const TXTLOG_SETUPAPI_DEVLOG: u32 = 1u32;
11522 pub const TXTLOG_SIGVERIF: u32 = 32u32;
11523 pub const TXTLOG_SUMMARY: u32 = 4u32;
11524 pub const TXTLOG_SYSTEM_STATE_CHANGE: u32 = 3u32;
11525 pub const TXTLOG_TAB_1: u32 = 524288u32;
11526 pub const TXTLOG_TIMESTAMP: u32 = 65536u32;
11527 pub const TXTLOG_UI: u32 = 256u32;
11528 pub const TXTLOG_UMPNPMGR: u32 = 33554432u32;
11529 pub const TXTLOG_UTIL: u32 = 512u32;
11530 pub const TXTLOG_VENDOR: u32 = 2147483648u32;
11531 pub const TXTLOG_VERBOSE: u32 = 6u32;
11532 pub const TXTLOG_VERY_VERBOSE: u32 = 7u32;
11533 pub const TXTLOG_WARNING: u32 = 2u32;
11534 #[cfg(feature = "Win32_Foundation")]
11535 #[inline]
TestApplyPatchToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL11536 pub unsafe fn TestApplyPatchToFileA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(patchfilename: Param0, oldfilename: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL {
11537     #[cfg(windows)]
11538     {
11539         #[link(name = "windows")]
11540         extern "system" {
11541             fn TestApplyPatchToFileA(patchfilename: super::super::Foundation::PSTR, oldfilename: super::super::Foundation::PSTR, applyoptionflags: u32) -> super::super::Foundation::BOOL;
11542         }
11543         ::std::mem::transmute(TestApplyPatchToFileA(patchfilename.into_param().abi(), oldfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
11544     }
11545     #[cfg(not(windows))]
11546     unimplemented!("Unsupported target OS");
11547 }
11548 #[cfg(feature = "Win32_Foundation")]
11549 #[inline]
TestApplyPatchToFileByBuffers(patchfilebuffer: *const u8, patchfilesize: u32, oldfilebuffer: *const u8, oldfilesize: u32, newfilesize: *mut u32, applyoptionflags: u32) -> super::super::Foundation::BOOL11550 pub unsafe fn TestApplyPatchToFileByBuffers(patchfilebuffer: *const u8, patchfilesize: u32, oldfilebuffer: *const u8, oldfilesize: u32, newfilesize: *mut u32, applyoptionflags: u32) -> super::super::Foundation::BOOL {
11551     #[cfg(windows)]
11552     {
11553         #[link(name = "windows")]
11554         extern "system" {
11555             fn TestApplyPatchToFileByBuffers(patchfilebuffer: *const u8, patchfilesize: u32, oldfilebuffer: *const u8, oldfilesize: u32, newfilesize: *mut u32, applyoptionflags: u32) -> super::super::Foundation::BOOL;
11556         }
11557         ::std::mem::transmute(TestApplyPatchToFileByBuffers(::std::mem::transmute(patchfilebuffer), ::std::mem::transmute(patchfilesize), ::std::mem::transmute(oldfilebuffer), ::std::mem::transmute(oldfilesize), ::std::mem::transmute(newfilesize), ::std::mem::transmute(applyoptionflags)))
11558     }
11559     #[cfg(not(windows))]
11560     unimplemented!("Unsupported target OS");
11561 }
11562 #[cfg(feature = "Win32_Foundation")]
11563 #[inline]
TestApplyPatchToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, oldfilehandle: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL11564 pub unsafe fn TestApplyPatchToFileByHandles<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(patchfilehandle: Param0, oldfilehandle: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL {
11565     #[cfg(windows)]
11566     {
11567         #[link(name = "windows")]
11568         extern "system" {
11569             fn TestApplyPatchToFileByHandles(patchfilehandle: super::super::Foundation::HANDLE, oldfilehandle: super::super::Foundation::HANDLE, applyoptionflags: u32) -> super::super::Foundation::BOOL;
11570         }
11571         ::std::mem::transmute(TestApplyPatchToFileByHandles(patchfilehandle.into_param().abi(), oldfilehandle.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
11572     }
11573     #[cfg(not(windows))]
11574     unimplemented!("Unsupported target OS");
11575 }
11576 #[cfg(feature = "Win32_Foundation")]
11577 #[inline]
TestApplyPatchToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL11578 pub unsafe fn TestApplyPatchToFileW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(patchfilename: Param0, oldfilename: Param1, applyoptionflags: u32) -> super::super::Foundation::BOOL {
11579     #[cfg(windows)]
11580     {
11581         #[link(name = "windows")]
11582         extern "system" {
11583             fn TestApplyPatchToFileW(patchfilename: super::super::Foundation::PWSTR, oldfilename: super::super::Foundation::PWSTR, applyoptionflags: u32) -> super::super::Foundation::BOOL;
11584         }
11585         ::std::mem::transmute(TestApplyPatchToFileW(patchfilename.into_param().abi(), oldfilename.into_param().abi(), ::std::mem::transmute(applyoptionflags)))
11586     }
11587     #[cfg(not(windows))]
11588     unimplemented!("Unsupported target OS");
11589 }
11590 pub const UIALL: u32 = 32768u32;
11591 pub const UILOGBITS: u32 = 15u32;
11592 pub const UINONE: u32 = 0u32;
11593 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11594 #[repr(transparent)]
11595 pub struct USERINFOSTATE(pub i32);
11596 pub const USERINFOSTATE_MOREDATA: USERINFOSTATE = USERINFOSTATE(-3i32);
11597 pub const USERINFOSTATE_INVALIDARG: USERINFOSTATE = USERINFOSTATE(-2i32);
11598 pub const USERINFOSTATE_UNKNOWN: USERINFOSTATE = USERINFOSTATE(-1i32);
11599 pub const USERINFOSTATE_ABSENT: USERINFOSTATE = USERINFOSTATE(0i32);
11600 pub const USERINFOSTATE_PRESENT: USERINFOSTATE = USERINFOSTATE(1i32);
11601 impl ::std::convert::From<i32> for USERINFOSTATE {
from(value: i32) -> Self11602     fn from(value: i32) -> Self {
11603         Self(value)
11604     }
11605 }
11606 unsafe impl ::windows::runtime::Abi for USERINFOSTATE {
11607     type Abi = Self;
11608     type DefaultType = Self;
11609 }
11610 pub const WARN_BAD_MAJOR_VERSION: u32 = 3222294792u32;
11611 pub const WARN_BASE: u32 = 3222294785u32;
11612 pub const WARN_EQUAL_FILE_VERSION: u32 = 3222294794u32;
11613 pub const WARN_FILE_VERSION_DOWNREV: u32 = 3222294793u32;
11614 pub const WARN_IMPROPER_TRANSFORM_VALIDATION: u32 = 3222294788u32;
11615 pub const WARN_INVALID_TRANSFORM_VALIDATION: u32 = 3222294791u32;
11616 pub const WARN_MAJOR_UPGRADE_PATCH: u32 = 3222294785u32;
11617 pub const WARN_OBSOLETION_WITH_MSI30: u32 = 3222294801u32;
11618 pub const WARN_OBSOLETION_WITH_PATCHSEQUENCE: u32 = 3222294803u32;
11619 pub const WARN_OBSOLETION_WITH_SEQUENCE_DATA: u32 = 3222294802u32;
11620 pub const WARN_PATCHPROPERTYNOTSET: u32 = 3222294795u32;
11621 pub const WARN_PCW_MISMATCHED_PRODUCT_CODES: u32 = 3222294789u32;
11622 pub const WARN_PCW_MISMATCHED_PRODUCT_VERSIONS: u32 = 3222294790u32;
11623 pub const WARN_SEQUENCE_DATA_GENERATION_DISABLED: u32 = 3222294786u32;
11624 pub const WARN_SEQUENCE_DATA_SUPERSEDENCE_IGNORED: u32 = 3222294787u32;
11625 #[cfg(feature = "Win32_Foundation")]
11626 #[inline]
ZombifyActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0) -> super::super::Foundation::BOOL11627 pub unsafe fn ZombifyActCtx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hactctx: Param0) -> super::super::Foundation::BOOL {
11628     #[cfg(windows)]
11629     {
11630         #[link(name = "windows")]
11631         extern "system" {
11632             fn ZombifyActCtx(hactctx: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
11633         }
11634         ::std::mem::transmute(ZombifyActCtx(hactctx.into_param().abi()))
11635     }
11636     #[cfg(not(windows))]
11637     unimplemented!("Unsupported target OS");
11638 }
11639 pub const _WIN32_MSI: u32 = 500u32;
11640 pub const _WIN32_MSM: u32 = 100u32;
11641 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11642 #[repr(C)]
11643 pub struct _tagAPPTASKTYPE {
11644     pub ProductID: ::windows::runtime::GUID,
11645     pub TaskType: PM_TASK_TYPE,
11646 }
11647 impl _tagAPPTASKTYPE {}
11648 impl ::std::default::Default for _tagAPPTASKTYPE {
default() -> Self11649     fn default() -> Self {
11650         unsafe { ::std::mem::zeroed() }
11651     }
11652 }
11653 impl ::std::fmt::Debug for _tagAPPTASKTYPE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11654     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11655         fmt.debug_struct("_tagAPPTASKTYPE").field("ProductID", &self.ProductID).field("TaskType", &self.TaskType).finish()
11656     }
11657 }
11658 impl ::std::cmp::PartialEq for _tagAPPTASKTYPE {
eq(&self, other: &Self) -> bool11659     fn eq(&self, other: &Self) -> bool {
11660         self.ProductID == other.ProductID && self.TaskType == other.TaskType
11661     }
11662 }
11663 impl ::std::cmp::Eq for _tagAPPTASKTYPE {}
11664 unsafe impl ::windows::runtime::Abi for _tagAPPTASKTYPE {
11665     type Abi = Self;
11666     type DefaultType = Self;
11667 }
11668 pub const cchMaxInteger: i32 = 12i32;
11669 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11670 #[repr(transparent)]
11671 pub struct msidbAssemblyAttributes(pub i32);
11672 pub const msidbAssemblyAttributesURT: msidbAssemblyAttributes = msidbAssemblyAttributes(0i32);
11673 pub const msidbAssemblyAttributesWin32: msidbAssemblyAttributes = msidbAssemblyAttributes(1i32);
11674 impl ::std::convert::From<i32> for msidbAssemblyAttributes {
from(value: i32) -> Self11675     fn from(value: i32) -> Self {
11676         Self(value)
11677     }
11678 }
11679 unsafe impl ::windows::runtime::Abi for msidbAssemblyAttributes {
11680     type Abi = Self;
11681     type DefaultType = Self;
11682 }
11683 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11684 #[repr(transparent)]
11685 pub struct msidbClassAttributes(pub i32);
11686 pub const msidbClassAttributesRelativePath: msidbClassAttributes = msidbClassAttributes(1i32);
11687 impl ::std::convert::From<i32> for msidbClassAttributes {
from(value: i32) -> Self11688     fn from(value: i32) -> Self {
11689         Self(value)
11690     }
11691 }
11692 unsafe impl ::windows::runtime::Abi for msidbClassAttributes {
11693     type Abi = Self;
11694     type DefaultType = Self;
11695 }
11696 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11697 #[repr(transparent)]
11698 pub struct msidbComponentAttributes(pub i32);
11699 pub const msidbComponentAttributesLocalOnly: msidbComponentAttributes = msidbComponentAttributes(0i32);
11700 pub const msidbComponentAttributesSourceOnly: msidbComponentAttributes = msidbComponentAttributes(1i32);
11701 pub const msidbComponentAttributesOptional: msidbComponentAttributes = msidbComponentAttributes(2i32);
11702 pub const msidbComponentAttributesRegistryKeyPath: msidbComponentAttributes = msidbComponentAttributes(4i32);
11703 pub const msidbComponentAttributesSharedDllRefCount: msidbComponentAttributes = msidbComponentAttributes(8i32);
11704 pub const msidbComponentAttributesPermanent: msidbComponentAttributes = msidbComponentAttributes(16i32);
11705 pub const msidbComponentAttributesODBCDataSource: msidbComponentAttributes = msidbComponentAttributes(32i32);
11706 pub const msidbComponentAttributesTransitive: msidbComponentAttributes = msidbComponentAttributes(64i32);
11707 pub const msidbComponentAttributesNeverOverwrite: msidbComponentAttributes = msidbComponentAttributes(128i32);
11708 pub const msidbComponentAttributes64bit: msidbComponentAttributes = msidbComponentAttributes(256i32);
11709 pub const msidbComponentAttributesDisableRegistryReflection: msidbComponentAttributes = msidbComponentAttributes(512i32);
11710 pub const msidbComponentAttributesUninstallOnSupersedence: msidbComponentAttributes = msidbComponentAttributes(1024i32);
11711 pub const msidbComponentAttributesShared: msidbComponentAttributes = msidbComponentAttributes(2048i32);
11712 impl ::std::convert::From<i32> for msidbComponentAttributes {
from(value: i32) -> Self11713     fn from(value: i32) -> Self {
11714         Self(value)
11715     }
11716 }
11717 unsafe impl ::windows::runtime::Abi for msidbComponentAttributes {
11718     type Abi = Self;
11719     type DefaultType = Self;
11720 }
11721 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11722 #[repr(transparent)]
11723 pub struct msidbControlAttributes(pub i32);
11724 pub const msidbControlAttributesVisible: msidbControlAttributes = msidbControlAttributes(1i32);
11725 pub const msidbControlAttributesEnabled: msidbControlAttributes = msidbControlAttributes(2i32);
11726 pub const msidbControlAttributesSunken: msidbControlAttributes = msidbControlAttributes(4i32);
11727 pub const msidbControlAttributesIndirect: msidbControlAttributes = msidbControlAttributes(8i32);
11728 pub const msidbControlAttributesInteger: msidbControlAttributes = msidbControlAttributes(16i32);
11729 pub const msidbControlAttributesRTLRO: msidbControlAttributes = msidbControlAttributes(32i32);
11730 pub const msidbControlAttributesRightAligned: msidbControlAttributes = msidbControlAttributes(64i32);
11731 pub const msidbControlAttributesLeftScroll: msidbControlAttributes = msidbControlAttributes(128i32);
11732 pub const msidbControlAttributesBiDi: msidbControlAttributes = msidbControlAttributes(224i32);
11733 pub const msidbControlAttributesTransparent: msidbControlAttributes = msidbControlAttributes(65536i32);
11734 pub const msidbControlAttributesNoPrefix: msidbControlAttributes = msidbControlAttributes(131072i32);
11735 pub const msidbControlAttributesNoWrap: msidbControlAttributes = msidbControlAttributes(262144i32);
11736 pub const msidbControlAttributesFormatSize: msidbControlAttributes = msidbControlAttributes(524288i32);
11737 pub const msidbControlAttributesUsersLanguage: msidbControlAttributes = msidbControlAttributes(1048576i32);
11738 pub const msidbControlAttributesMultiline: msidbControlAttributes = msidbControlAttributes(65536i32);
11739 pub const msidbControlAttributesPasswordInput: msidbControlAttributes = msidbControlAttributes(2097152i32);
11740 pub const msidbControlAttributesProgress95: msidbControlAttributes = msidbControlAttributes(65536i32);
11741 pub const msidbControlAttributesRemovableVolume: msidbControlAttributes = msidbControlAttributes(65536i32);
11742 pub const msidbControlAttributesFixedVolume: msidbControlAttributes = msidbControlAttributes(131072i32);
11743 pub const msidbControlAttributesRemoteVolume: msidbControlAttributes = msidbControlAttributes(262144i32);
11744 pub const msidbControlAttributesCDROMVolume: msidbControlAttributes = msidbControlAttributes(524288i32);
11745 pub const msidbControlAttributesRAMDiskVolume: msidbControlAttributes = msidbControlAttributes(1048576i32);
11746 pub const msidbControlAttributesFloppyVolume: msidbControlAttributes = msidbControlAttributes(2097152i32);
11747 pub const msidbControlShowRollbackCost: msidbControlAttributes = msidbControlAttributes(4194304i32);
11748 pub const msidbControlAttributesSorted: msidbControlAttributes = msidbControlAttributes(65536i32);
11749 pub const msidbControlAttributesComboList: msidbControlAttributes = msidbControlAttributes(131072i32);
11750 pub const msidbControlAttributesImageHandle: msidbControlAttributes = msidbControlAttributes(65536i32);
11751 pub const msidbControlAttributesPushLike: msidbControlAttributes = msidbControlAttributes(131072i32);
11752 pub const msidbControlAttributesBitmap: msidbControlAttributes = msidbControlAttributes(262144i32);
11753 pub const msidbControlAttributesIcon: msidbControlAttributes = msidbControlAttributes(524288i32);
11754 pub const msidbControlAttributesFixedSize: msidbControlAttributes = msidbControlAttributes(1048576i32);
11755 pub const msidbControlAttributesIconSize16: msidbControlAttributes = msidbControlAttributes(2097152i32);
11756 pub const msidbControlAttributesIconSize32: msidbControlAttributes = msidbControlAttributes(4194304i32);
11757 pub const msidbControlAttributesIconSize48: msidbControlAttributes = msidbControlAttributes(6291456i32);
11758 pub const msidbControlAttributesElevationShield: msidbControlAttributes = msidbControlAttributes(8388608i32);
11759 pub const msidbControlAttributesHasBorder: msidbControlAttributes = msidbControlAttributes(16777216i32);
11760 impl ::std::convert::From<i32> for msidbControlAttributes {
from(value: i32) -> Self11761     fn from(value: i32) -> Self {
11762         Self(value)
11763     }
11764 }
11765 unsafe impl ::windows::runtime::Abi for msidbControlAttributes {
11766     type Abi = Self;
11767     type DefaultType = Self;
11768 }
11769 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11770 #[repr(transparent)]
11771 pub struct msidbCustomActionType(pub i32);
11772 pub const msidbCustomActionTypeDll: msidbCustomActionType = msidbCustomActionType(1i32);
11773 pub const msidbCustomActionTypeExe: msidbCustomActionType = msidbCustomActionType(2i32);
11774 pub const msidbCustomActionTypeTextData: msidbCustomActionType = msidbCustomActionType(3i32);
11775 pub const msidbCustomActionTypeJScript: msidbCustomActionType = msidbCustomActionType(5i32);
11776 pub const msidbCustomActionTypeVBScript: msidbCustomActionType = msidbCustomActionType(6i32);
11777 pub const msidbCustomActionTypeInstall: msidbCustomActionType = msidbCustomActionType(7i32);
11778 pub const msidbCustomActionTypeBinaryData: msidbCustomActionType = msidbCustomActionType(0i32);
11779 pub const msidbCustomActionTypeSourceFile: msidbCustomActionType = msidbCustomActionType(16i32);
11780 pub const msidbCustomActionTypeDirectory: msidbCustomActionType = msidbCustomActionType(32i32);
11781 pub const msidbCustomActionTypeProperty: msidbCustomActionType = msidbCustomActionType(48i32);
11782 pub const msidbCustomActionTypeContinue: msidbCustomActionType = msidbCustomActionType(64i32);
11783 pub const msidbCustomActionTypeAsync: msidbCustomActionType = msidbCustomActionType(128i32);
11784 pub const msidbCustomActionTypeFirstSequence: msidbCustomActionType = msidbCustomActionType(256i32);
11785 pub const msidbCustomActionTypeOncePerProcess: msidbCustomActionType = msidbCustomActionType(512i32);
11786 pub const msidbCustomActionTypeClientRepeat: msidbCustomActionType = msidbCustomActionType(768i32);
11787 pub const msidbCustomActionTypeInScript: msidbCustomActionType = msidbCustomActionType(1024i32);
11788 pub const msidbCustomActionTypeRollback: msidbCustomActionType = msidbCustomActionType(256i32);
11789 pub const msidbCustomActionTypeCommit: msidbCustomActionType = msidbCustomActionType(512i32);
11790 pub const msidbCustomActionTypeNoImpersonate: msidbCustomActionType = msidbCustomActionType(2048i32);
11791 pub const msidbCustomActionTypeTSAware: msidbCustomActionType = msidbCustomActionType(16384i32);
11792 pub const msidbCustomActionType64BitScript: msidbCustomActionType = msidbCustomActionType(4096i32);
11793 pub const msidbCustomActionTypeHideTarget: msidbCustomActionType = msidbCustomActionType(8192i32);
11794 pub const msidbCustomActionTypePatchUninstall: msidbCustomActionType = msidbCustomActionType(32768i32);
11795 impl ::std::convert::From<i32> for msidbCustomActionType {
from(value: i32) -> Self11796     fn from(value: i32) -> Self {
11797         Self(value)
11798     }
11799 }
11800 unsafe impl ::windows::runtime::Abi for msidbCustomActionType {
11801     type Abi = Self;
11802     type DefaultType = Self;
11803 }
11804 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11805 #[repr(transparent)]
11806 pub struct msidbDialogAttributes(pub i32);
11807 pub const msidbDialogAttributesVisible: msidbDialogAttributes = msidbDialogAttributes(1i32);
11808 pub const msidbDialogAttributesModal: msidbDialogAttributes = msidbDialogAttributes(2i32);
11809 pub const msidbDialogAttributesMinimize: msidbDialogAttributes = msidbDialogAttributes(4i32);
11810 pub const msidbDialogAttributesSysModal: msidbDialogAttributes = msidbDialogAttributes(8i32);
11811 pub const msidbDialogAttributesKeepModeless: msidbDialogAttributes = msidbDialogAttributes(16i32);
11812 pub const msidbDialogAttributesTrackDiskSpace: msidbDialogAttributes = msidbDialogAttributes(32i32);
11813 pub const msidbDialogAttributesUseCustomPalette: msidbDialogAttributes = msidbDialogAttributes(64i32);
11814 pub const msidbDialogAttributesRTLRO: msidbDialogAttributes = msidbDialogAttributes(128i32);
11815 pub const msidbDialogAttributesRightAligned: msidbDialogAttributes = msidbDialogAttributes(256i32);
11816 pub const msidbDialogAttributesLeftScroll: msidbDialogAttributes = msidbDialogAttributes(512i32);
11817 pub const msidbDialogAttributesBiDi: msidbDialogAttributes = msidbDialogAttributes(896i32);
11818 pub const msidbDialogAttributesError: msidbDialogAttributes = msidbDialogAttributes(65536i32);
11819 impl ::std::convert::From<i32> for msidbDialogAttributes {
from(value: i32) -> Self11820     fn from(value: i32) -> Self {
11821         Self(value)
11822     }
11823 }
11824 unsafe impl ::windows::runtime::Abi for msidbDialogAttributes {
11825     type Abi = Self;
11826     type DefaultType = Self;
11827 }
11828 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11829 #[repr(transparent)]
11830 pub struct msidbEmbeddedUIAttributes(pub i32);
11831 pub const msidbEmbeddedUI: msidbEmbeddedUIAttributes = msidbEmbeddedUIAttributes(1i32);
11832 pub const msidbEmbeddedHandlesBasic: msidbEmbeddedUIAttributes = msidbEmbeddedUIAttributes(2i32);
11833 impl ::std::convert::From<i32> for msidbEmbeddedUIAttributes {
from(value: i32) -> Self11834     fn from(value: i32) -> Self {
11835         Self(value)
11836     }
11837 }
11838 unsafe impl ::windows::runtime::Abi for msidbEmbeddedUIAttributes {
11839     type Abi = Self;
11840     type DefaultType = Self;
11841 }
11842 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11843 #[repr(transparent)]
11844 pub struct msidbFeatureAttributes(pub i32);
11845 pub const msidbFeatureAttributesFavorLocal: msidbFeatureAttributes = msidbFeatureAttributes(0i32);
11846 pub const msidbFeatureAttributesFavorSource: msidbFeatureAttributes = msidbFeatureAttributes(1i32);
11847 pub const msidbFeatureAttributesFollowParent: msidbFeatureAttributes = msidbFeatureAttributes(2i32);
11848 pub const msidbFeatureAttributesFavorAdvertise: msidbFeatureAttributes = msidbFeatureAttributes(4i32);
11849 pub const msidbFeatureAttributesDisallowAdvertise: msidbFeatureAttributes = msidbFeatureAttributes(8i32);
11850 pub const msidbFeatureAttributesUIDisallowAbsent: msidbFeatureAttributes = msidbFeatureAttributes(16i32);
11851 pub const msidbFeatureAttributesNoUnsupportedAdvertise: msidbFeatureAttributes = msidbFeatureAttributes(32i32);
11852 impl ::std::convert::From<i32> for msidbFeatureAttributes {
from(value: i32) -> Self11853     fn from(value: i32) -> Self {
11854         Self(value)
11855     }
11856 }
11857 unsafe impl ::windows::runtime::Abi for msidbFeatureAttributes {
11858     type Abi = Self;
11859     type DefaultType = Self;
11860 }
11861 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11862 #[repr(transparent)]
11863 pub struct msidbFileAttributes(pub i32);
11864 pub const msidbFileAttributesReadOnly: msidbFileAttributes = msidbFileAttributes(1i32);
11865 pub const msidbFileAttributesHidden: msidbFileAttributes = msidbFileAttributes(2i32);
11866 pub const msidbFileAttributesSystem: msidbFileAttributes = msidbFileAttributes(4i32);
11867 pub const msidbFileAttributesReserved0: msidbFileAttributes = msidbFileAttributes(8i32);
11868 pub const msidbFileAttributesIsolatedComp: msidbFileAttributes = msidbFileAttributes(16i32);
11869 pub const msidbFileAttributesReserved1: msidbFileAttributes = msidbFileAttributes(64i32);
11870 pub const msidbFileAttributesReserved2: msidbFileAttributes = msidbFileAttributes(128i32);
11871 pub const msidbFileAttributesReserved3: msidbFileAttributes = msidbFileAttributes(256i32);
11872 pub const msidbFileAttributesVital: msidbFileAttributes = msidbFileAttributes(512i32);
11873 pub const msidbFileAttributesChecksum: msidbFileAttributes = msidbFileAttributes(1024i32);
11874 pub const msidbFileAttributesPatchAdded: msidbFileAttributes = msidbFileAttributes(4096i32);
11875 pub const msidbFileAttributesNoncompressed: msidbFileAttributes = msidbFileAttributes(8192i32);
11876 pub const msidbFileAttributesCompressed: msidbFileAttributes = msidbFileAttributes(16384i32);
11877 pub const msidbFileAttributesReserved4: msidbFileAttributes = msidbFileAttributes(32768i32);
11878 impl ::std::convert::From<i32> for msidbFileAttributes {
from(value: i32) -> Self11879     fn from(value: i32) -> Self {
11880         Self(value)
11881     }
11882 }
11883 unsafe impl ::windows::runtime::Abi for msidbFileAttributes {
11884     type Abi = Self;
11885     type DefaultType = Self;
11886 }
11887 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11888 #[repr(transparent)]
11889 pub struct msidbIniFileAction(pub i32);
11890 pub const msidbIniFileActionAddLine: msidbIniFileAction = msidbIniFileAction(0i32);
11891 pub const msidbIniFileActionCreateLine: msidbIniFileAction = msidbIniFileAction(1i32);
11892 pub const msidbIniFileActionRemoveLine: msidbIniFileAction = msidbIniFileAction(2i32);
11893 pub const msidbIniFileActionAddTag: msidbIniFileAction = msidbIniFileAction(3i32);
11894 pub const msidbIniFileActionRemoveTag: msidbIniFileAction = msidbIniFileAction(4i32);
11895 impl ::std::convert::From<i32> for msidbIniFileAction {
from(value: i32) -> Self11896     fn from(value: i32) -> Self {
11897         Self(value)
11898     }
11899 }
11900 unsafe impl ::windows::runtime::Abi for msidbIniFileAction {
11901     type Abi = Self;
11902     type DefaultType = Self;
11903 }
11904 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11905 #[repr(transparent)]
11906 pub struct msidbLocatorType(pub i32);
11907 pub const msidbLocatorTypeDirectory: msidbLocatorType = msidbLocatorType(0i32);
11908 pub const msidbLocatorTypeFileName: msidbLocatorType = msidbLocatorType(1i32);
11909 pub const msidbLocatorTypeRawValue: msidbLocatorType = msidbLocatorType(2i32);
11910 pub const msidbLocatorType64bit: msidbLocatorType = msidbLocatorType(16i32);
11911 impl ::std::convert::From<i32> for msidbLocatorType {
from(value: i32) -> Self11912     fn from(value: i32) -> Self {
11913         Self(value)
11914     }
11915 }
11916 unsafe impl ::windows::runtime::Abi for msidbLocatorType {
11917     type Abi = Self;
11918     type DefaultType = Self;
11919 }
11920 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11921 #[repr(transparent)]
11922 pub struct msidbMoveFileOptions(pub i32);
11923 pub const msidbMoveFileOptionsMove: msidbMoveFileOptions = msidbMoveFileOptions(1i32);
11924 impl ::std::convert::From<i32> for msidbMoveFileOptions {
from(value: i32) -> Self11925     fn from(value: i32) -> Self {
11926         Self(value)
11927     }
11928 }
11929 unsafe impl ::windows::runtime::Abi for msidbMoveFileOptions {
11930     type Abi = Self;
11931     type DefaultType = Self;
11932 }
11933 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11934 #[repr(transparent)]
11935 pub struct msidbODBCDataSourceRegistration(pub i32);
11936 pub const msidbODBCDataSourceRegistrationPerMachine: msidbODBCDataSourceRegistration = msidbODBCDataSourceRegistration(0i32);
11937 pub const msidbODBCDataSourceRegistrationPerUser: msidbODBCDataSourceRegistration = msidbODBCDataSourceRegistration(1i32);
11938 impl ::std::convert::From<i32> for msidbODBCDataSourceRegistration {
from(value: i32) -> Self11939     fn from(value: i32) -> Self {
11940         Self(value)
11941     }
11942 }
11943 unsafe impl ::windows::runtime::Abi for msidbODBCDataSourceRegistration {
11944     type Abi = Self;
11945     type DefaultType = Self;
11946 }
11947 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11948 #[repr(transparent)]
11949 pub struct msidbPatchAttributes(pub i32);
11950 pub const msidbPatchAttributesNonVital: msidbPatchAttributes = msidbPatchAttributes(1i32);
11951 impl ::std::convert::From<i32> for msidbPatchAttributes {
from(value: i32) -> Self11952     fn from(value: i32) -> Self {
11953         Self(value)
11954     }
11955 }
11956 unsafe impl ::windows::runtime::Abi for msidbPatchAttributes {
11957     type Abi = Self;
11958     type DefaultType = Self;
11959 }
11960 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11961 #[repr(transparent)]
11962 pub struct msidbRegistryRoot(pub i32);
11963 pub const msidbRegistryRootClassesRoot: msidbRegistryRoot = msidbRegistryRoot(0i32);
11964 pub const msidbRegistryRootCurrentUser: msidbRegistryRoot = msidbRegistryRoot(1i32);
11965 pub const msidbRegistryRootLocalMachine: msidbRegistryRoot = msidbRegistryRoot(2i32);
11966 pub const msidbRegistryRootUsers: msidbRegistryRoot = msidbRegistryRoot(3i32);
11967 impl ::std::convert::From<i32> for msidbRegistryRoot {
from(value: i32) -> Self11968     fn from(value: i32) -> Self {
11969         Self(value)
11970     }
11971 }
11972 unsafe impl ::windows::runtime::Abi for msidbRegistryRoot {
11973     type Abi = Self;
11974     type DefaultType = Self;
11975 }
11976 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11977 #[repr(transparent)]
11978 pub struct msidbRemoveFileInstallMode(pub i32);
11979 pub const msidbRemoveFileInstallModeOnInstall: msidbRemoveFileInstallMode = msidbRemoveFileInstallMode(1i32);
11980 pub const msidbRemoveFileInstallModeOnRemove: msidbRemoveFileInstallMode = msidbRemoveFileInstallMode(2i32);
11981 pub const msidbRemoveFileInstallModeOnBoth: msidbRemoveFileInstallMode = msidbRemoveFileInstallMode(3i32);
11982 impl ::std::convert::From<i32> for msidbRemoveFileInstallMode {
from(value: i32) -> Self11983     fn from(value: i32) -> Self {
11984         Self(value)
11985     }
11986 }
11987 unsafe impl ::windows::runtime::Abi for msidbRemoveFileInstallMode {
11988     type Abi = Self;
11989     type DefaultType = Self;
11990 }
11991 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11992 #[repr(transparent)]
11993 pub struct msidbServiceConfigEvent(pub i32);
11994 pub const msidbServiceConfigEventInstall: msidbServiceConfigEvent = msidbServiceConfigEvent(1i32);
11995 pub const msidbServiceConfigEventUninstall: msidbServiceConfigEvent = msidbServiceConfigEvent(2i32);
11996 pub const msidbServiceConfigEventReinstall: msidbServiceConfigEvent = msidbServiceConfigEvent(4i32);
11997 impl ::std::convert::From<i32> for msidbServiceConfigEvent {
from(value: i32) -> Self11998     fn from(value: i32) -> Self {
11999         Self(value)
12000     }
12001 }
12002 unsafe impl ::windows::runtime::Abi for msidbServiceConfigEvent {
12003     type Abi = Self;
12004     type DefaultType = Self;
12005 }
12006 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12007 #[repr(transparent)]
12008 pub struct msidbServiceControlEvent(pub i32);
12009 pub const msidbServiceControlEventStart: msidbServiceControlEvent = msidbServiceControlEvent(1i32);
12010 pub const msidbServiceControlEventStop: msidbServiceControlEvent = msidbServiceControlEvent(2i32);
12011 pub const msidbServiceControlEventDelete: msidbServiceControlEvent = msidbServiceControlEvent(8i32);
12012 pub const msidbServiceControlEventUninstallStart: msidbServiceControlEvent = msidbServiceControlEvent(16i32);
12013 pub const msidbServiceControlEventUninstallStop: msidbServiceControlEvent = msidbServiceControlEvent(32i32);
12014 pub const msidbServiceControlEventUninstallDelete: msidbServiceControlEvent = msidbServiceControlEvent(128i32);
12015 impl ::std::convert::From<i32> for msidbServiceControlEvent {
from(value: i32) -> Self12016     fn from(value: i32) -> Self {
12017         Self(value)
12018     }
12019 }
12020 unsafe impl ::windows::runtime::Abi for msidbServiceControlEvent {
12021     type Abi = Self;
12022     type DefaultType = Self;
12023 }
12024 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12025 #[repr(transparent)]
12026 pub struct msidbServiceInstallErrorControl(pub i32);
12027 pub const msidbServiceInstallErrorControlVital: msidbServiceInstallErrorControl = msidbServiceInstallErrorControl(32768i32);
12028 impl ::std::convert::From<i32> for msidbServiceInstallErrorControl {
from(value: i32) -> Self12029     fn from(value: i32) -> Self {
12030         Self(value)
12031     }
12032 }
12033 unsafe impl ::windows::runtime::Abi for msidbServiceInstallErrorControl {
12034     type Abi = Self;
12035     type DefaultType = Self;
12036 }
12037 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12038 #[repr(transparent)]
12039 pub struct msidbSumInfoSourceType(pub i32);
12040 pub const msidbSumInfoSourceTypeSFN: msidbSumInfoSourceType = msidbSumInfoSourceType(1i32);
12041 pub const msidbSumInfoSourceTypeCompressed: msidbSumInfoSourceType = msidbSumInfoSourceType(2i32);
12042 pub const msidbSumInfoSourceTypeAdminImage: msidbSumInfoSourceType = msidbSumInfoSourceType(4i32);
12043 pub const msidbSumInfoSourceTypeLUAPackage: msidbSumInfoSourceType = msidbSumInfoSourceType(8i32);
12044 impl ::std::convert::From<i32> for msidbSumInfoSourceType {
from(value: i32) -> Self12045     fn from(value: i32) -> Self {
12046         Self(value)
12047     }
12048 }
12049 unsafe impl ::windows::runtime::Abi for msidbSumInfoSourceType {
12050     type Abi = Self;
12051     type DefaultType = Self;
12052 }
12053 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12054 #[repr(transparent)]
12055 pub struct msidbTextStyleStyleBits(pub i32);
12056 pub const msidbTextStyleStyleBitsBold: msidbTextStyleStyleBits = msidbTextStyleStyleBits(1i32);
12057 pub const msidbTextStyleStyleBitsItalic: msidbTextStyleStyleBits = msidbTextStyleStyleBits(2i32);
12058 pub const msidbTextStyleStyleBitsUnderline: msidbTextStyleStyleBits = msidbTextStyleStyleBits(4i32);
12059 pub const msidbTextStyleStyleBitsStrike: msidbTextStyleStyleBits = msidbTextStyleStyleBits(8i32);
12060 impl ::std::convert::From<i32> for msidbTextStyleStyleBits {
from(value: i32) -> Self12061     fn from(value: i32) -> Self {
12062         Self(value)
12063     }
12064 }
12065 unsafe impl ::windows::runtime::Abi for msidbTextStyleStyleBits {
12066     type Abi = Self;
12067     type DefaultType = Self;
12068 }
12069 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12070 #[repr(transparent)]
12071 pub struct msidbUpgradeAttributes(pub i32);
12072 pub const msidbUpgradeAttributesMigrateFeatures: msidbUpgradeAttributes = msidbUpgradeAttributes(1i32);
12073 pub const msidbUpgradeAttributesOnlyDetect: msidbUpgradeAttributes = msidbUpgradeAttributes(2i32);
12074 pub const msidbUpgradeAttributesIgnoreRemoveFailure: msidbUpgradeAttributes = msidbUpgradeAttributes(4i32);
12075 pub const msidbUpgradeAttributesVersionMinInclusive: msidbUpgradeAttributes = msidbUpgradeAttributes(256i32);
12076 pub const msidbUpgradeAttributesVersionMaxInclusive: msidbUpgradeAttributes = msidbUpgradeAttributes(512i32);
12077 pub const msidbUpgradeAttributesLanguagesExclusive: msidbUpgradeAttributes = msidbUpgradeAttributes(1024i32);
12078 impl ::std::convert::From<i32> for msidbUpgradeAttributes {
from(value: i32) -> Self12079     fn from(value: i32) -> Self {
12080         Self(value)
12081     }
12082 }
12083 unsafe impl ::windows::runtime::Abi for msidbUpgradeAttributes {
12084     type Abi = Self;
12085     type DefaultType = Self;
12086 }
12087 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12088 #[repr(transparent)]
12089 pub struct msifiFastInstallBits(pub i32);
12090 pub const msifiFastInstallNoSR: msifiFastInstallBits = msifiFastInstallBits(1i32);
12091 pub const msifiFastInstallQuickCosting: msifiFastInstallBits = msifiFastInstallBits(2i32);
12092 pub const msifiFastInstallLessPrgMsg: msifiFastInstallBits = msifiFastInstallBits(4i32);
12093 impl ::std::convert::From<i32> for msifiFastInstallBits {
from(value: i32) -> Self12094     fn from(value: i32) -> Self {
12095         Self(value)
12096     }
12097 }
12098 unsafe impl ::windows::runtime::Abi for msifiFastInstallBits {
12099     type Abi = Self;
12100     type DefaultType = Self;
12101 }
12102 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12103 #[repr(transparent)]
12104 pub struct msirbRebootReason(pub i32);
12105 pub const msirbRebootUndeterminedReason: msirbRebootReason = msirbRebootReason(0i32);
12106 pub const msirbRebootInUseFilesReason: msirbRebootReason = msirbRebootReason(1i32);
12107 pub const msirbRebootScheduleRebootReason: msirbRebootReason = msirbRebootReason(2i32);
12108 pub const msirbRebootForceRebootReason: msirbRebootReason = msirbRebootReason(3i32);
12109 pub const msirbRebootCustomActionReason: msirbRebootReason = msirbRebootReason(4i32);
12110 impl ::std::convert::From<i32> for msirbRebootReason {
from(value: i32) -> Self12111     fn from(value: i32) -> Self {
12112         Self(value)
12113     }
12114 }
12115 unsafe impl ::windows::runtime::Abi for msirbRebootReason {
12116     type Abi = Self;
12117     type DefaultType = Self;
12118 }
12119 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12120 #[repr(transparent)]
12121 pub struct msirbRebootType(pub i32);
12122 pub const msirbRebootImmediate: msirbRebootType = msirbRebootType(1i32);
12123 pub const msirbRebootDeferred: msirbRebootType = msirbRebootType(2i32);
12124 impl ::std::convert::From<i32> for msirbRebootType {
from(value: i32) -> Self12125     fn from(value: i32) -> Self {
12126         Self(value)
12127     }
12128 }
12129 unsafe impl ::windows::runtime::Abi for msirbRebootType {
12130     type Abi = Self;
12131     type DefaultType = Self;
12132 }
12133 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12134 #[repr(transparent)]
12135 pub struct msmErrorType(pub i32);
12136 pub const msmErrorLanguageUnsupported: msmErrorType = msmErrorType(1i32);
12137 pub const msmErrorLanguageFailed: msmErrorType = msmErrorType(2i32);
12138 pub const msmErrorExclusion: msmErrorType = msmErrorType(3i32);
12139 pub const msmErrorTableMerge: msmErrorType = msmErrorType(4i32);
12140 pub const msmErrorResequenceMerge: msmErrorType = msmErrorType(5i32);
12141 pub const msmErrorFileCreate: msmErrorType = msmErrorType(6i32);
12142 pub const msmErrorDirCreate: msmErrorType = msmErrorType(7i32);
12143 pub const msmErrorFeatureRequired: msmErrorType = msmErrorType(8i32);
12144 impl ::std::convert::From<i32> for msmErrorType {
from(value: i32) -> Self12145     fn from(value: i32) -> Self {
12146         Self(value)
12147     }
12148 }
12149 unsafe impl ::windows::runtime::Abi for msmErrorType {
12150     type Abi = Self;
12151     type DefaultType = Self;
12152 }
12153