1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3 #[repr(C)]
4 pub struct ARRAY_INFO {
5     pub Dimension: i32,
6     pub BufferConformanceMark: *mut u32,
7     pub BufferVarianceMark: *mut u32,
8     pub MaxCountArray: *mut u32,
9     pub OffsetArray: *mut u32,
10     pub ActualCountArray: *mut u32,
11 }
12 impl ARRAY_INFO {}
13 impl ::std::default::Default for ARRAY_INFO {
default() -> Self14     fn default() -> Self {
15         unsafe { ::std::mem::zeroed() }
16     }
17 }
18 impl ::std::fmt::Debug for ARRAY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result19     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20         fmt.debug_struct("ARRAY_INFO")
21             .field("Dimension", &self.Dimension)
22             .field("BufferConformanceMark", &self.BufferConformanceMark)
23             .field("BufferVarianceMark", &self.BufferVarianceMark)
24             .field("MaxCountArray", &self.MaxCountArray)
25             .field("OffsetArray", &self.OffsetArray)
26             .field("ActualCountArray", &self.ActualCountArray)
27             .finish()
28     }
29 }
30 impl ::std::cmp::PartialEq for ARRAY_INFO {
eq(&self, other: &Self) -> bool31     fn eq(&self, other: &Self) -> bool {
32         self.Dimension == other.Dimension && self.BufferConformanceMark == other.BufferConformanceMark && self.BufferVarianceMark == other.BufferVarianceMark && self.MaxCountArray == other.MaxCountArray && self.OffsetArray == other.OffsetArray && self.ActualCountArray == other.ActualCountArray
33     }
34 }
35 impl ::std::cmp::Eq for ARRAY_INFO {}
36 unsafe impl ::windows::runtime::Abi for ARRAY_INFO {
37     type Abi = Self;
38     type DefaultType = Self;
39 }
40 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
41 #[repr(C)]
42 pub struct BinaryParam {
43     pub Buffer: *mut ::std::ffi::c_void,
44     pub Size: i16,
45 }
46 impl BinaryParam {}
47 impl ::std::default::Default for BinaryParam {
default() -> Self48     fn default() -> Self {
49         unsafe { ::std::mem::zeroed() }
50     }
51 }
52 impl ::std::fmt::Debug for BinaryParam {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result53     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
54         fmt.debug_struct("BinaryParam").field("Buffer", &self.Buffer).field("Size", &self.Size).finish()
55     }
56 }
57 impl ::std::cmp::PartialEq for BinaryParam {
eq(&self, other: &Self) -> bool58     fn eq(&self, other: &Self) -> bool {
59         self.Buffer == other.Buffer && self.Size == other.Size
60     }
61 }
62 impl ::std::cmp::Eq for BinaryParam {}
63 unsafe impl ::windows::runtime::Abi for BinaryParam {
64     type Abi = Self;
65     type DefaultType = Self;
66 }
67 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
68 #[repr(C)]
69 pub union CLIENT_CALL_RETURN {
70     pub Pointer: *mut ::std::ffi::c_void,
71     pub Simple: isize,
72 }
73 impl CLIENT_CALL_RETURN {}
74 impl ::std::default::Default for CLIENT_CALL_RETURN {
default() -> Self75     fn default() -> Self {
76         unsafe { ::std::mem::zeroed() }
77     }
78 }
79 impl ::std::cmp::PartialEq for CLIENT_CALL_RETURN {
eq(&self, _other: &Self) -> bool80     fn eq(&self, _other: &Self) -> bool {
81         unimplemented!()
82     }
83 }
84 impl ::std::cmp::Eq for CLIENT_CALL_RETURN {}
85 unsafe impl ::windows::runtime::Abi for CLIENT_CALL_RETURN {
86     type Abi = Self;
87     type DefaultType = Self;
88 }
89 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
90 #[repr(C)]
91 pub struct COMM_FAULT_OFFSETS {
92     pub CommOffset: i16,
93     pub FaultOffset: i16,
94 }
95 impl COMM_FAULT_OFFSETS {}
96 impl ::std::default::Default for COMM_FAULT_OFFSETS {
default() -> Self97     fn default() -> Self {
98         unsafe { ::std::mem::zeroed() }
99     }
100 }
101 impl ::std::fmt::Debug for COMM_FAULT_OFFSETS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result102     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
103         fmt.debug_struct("COMM_FAULT_OFFSETS").field("CommOffset", &self.CommOffset).field("FaultOffset", &self.FaultOffset).finish()
104     }
105 }
106 impl ::std::cmp::PartialEq for COMM_FAULT_OFFSETS {
eq(&self, other: &Self) -> bool107     fn eq(&self, other: &Self) -> bool {
108         self.CommOffset == other.CommOffset && self.FaultOffset == other.FaultOffset
109     }
110 }
111 impl ::std::cmp::Eq for COMM_FAULT_OFFSETS {}
112 unsafe impl ::windows::runtime::Abi for COMM_FAULT_OFFSETS {
113     type Abi = Self;
114     type DefaultType = Self;
115 }
116 pub type CS_TAG_GETTING_ROUTINE = unsafe extern "system" fn(hbinding: *mut ::std::ffi::c_void, fserverside: i32, pulsendingtag: *mut u32, puldesiredreceivingtag: *mut u32, pulreceivingtag: *mut u32, pstatus: *mut u32);
117 pub type CS_TYPE_FROM_NETCS_ROUTINE = unsafe extern "system" fn(hbinding: *mut ::std::ffi::c_void, ulnetworkcodeset: u32, pnetworkdata: *mut u8, ulnetworkdatalength: u32, ullocalbuffersize: u32, plocaldata: *mut ::std::ffi::c_void, pullocaldatalength: *mut u32, pstatus: *mut u32);
118 pub type CS_TYPE_LOCAL_SIZE_ROUTINE = unsafe extern "system" fn(hbinding: *mut ::std::ffi::c_void, ulnetworkcodeset: u32, ulnetworkbuffersize: u32, conversiontype: *mut IDL_CS_CONVERT, pullocalbuffersize: *mut u32, pstatus: *mut u32);
119 pub type CS_TYPE_NET_SIZE_ROUTINE = unsafe extern "system" fn(hbinding: *mut ::std::ffi::c_void, ulnetworkcodeset: u32, ullocalbuffersize: u32, conversiontype: *mut IDL_CS_CONVERT, pulnetworkbuffersize: *mut u32, pstatus: *mut u32);
120 pub type CS_TYPE_TO_NETCS_ROUTINE = unsafe extern "system" fn(hbinding: *mut ::std::ffi::c_void, ulnetworkcodeset: u32, plocaldata: *mut ::std::ffi::c_void, ullocaldatalength: u32, pnetworkdata: *mut u8, pulnetworkdatalength: *mut u32, pstatus: *mut u32);
121 pub const DCE_C_ERROR_STRING_LEN: u32 = 256u32;
122 #[inline]
DceErrorInqTextA(rpcstatus: RPC_STATUS, errortext: *mut u8) -> RPC_STATUS123 pub unsafe fn DceErrorInqTextA(rpcstatus: RPC_STATUS, errortext: *mut u8) -> RPC_STATUS {
124     #[cfg(windows)]
125     {
126         #[link(name = "windows")]
127         extern "system" {
128             fn DceErrorInqTextA(rpcstatus: RPC_STATUS, errortext: *mut u8) -> RPC_STATUS;
129         }
130         ::std::mem::transmute(DceErrorInqTextA(::std::mem::transmute(rpcstatus), ::std::mem::transmute(errortext)))
131     }
132     #[cfg(not(windows))]
133     unimplemented!("Unsupported target OS");
134 }
135 #[inline]
DceErrorInqTextW(rpcstatus: RPC_STATUS, errortext: *mut u16) -> RPC_STATUS136 pub unsafe fn DceErrorInqTextW(rpcstatus: RPC_STATUS, errortext: *mut u16) -> RPC_STATUS {
137     #[cfg(windows)]
138     {
139         #[link(name = "windows")]
140         extern "system" {
141             fn DceErrorInqTextW(rpcstatus: RPC_STATUS, errortext: *mut u16) -> RPC_STATUS;
142         }
143         ::std::mem::transmute(DceErrorInqTextW(::std::mem::transmute(rpcstatus), ::std::mem::transmute(errortext)))
144     }
145     #[cfg(not(windows))]
146     unimplemented!("Unsupported target OS");
147 }
148 pub const EEInfoGCCOM: u32 = 11u32;
149 pub const EEInfoGCFRS: u32 = 12u32;
150 pub const EEInfoNextRecordsMissing: u32 = 2u32;
151 pub const EEInfoPreviousRecordsMissing: u32 = 1u32;
152 pub const EEInfoUseFileTime: u32 = 4u32;
153 #[cfg(feature = "Win32_System_Com")]
154 pub type EXPR_EVAL = unsafe extern "system" fn(param0: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
155 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
156 #[repr(transparent)]
157 pub struct EXPR_TOKEN(pub i32);
158 pub const FC_EXPR_START: EXPR_TOKEN = EXPR_TOKEN(0i32);
159 pub const FC_EXPR_ILLEGAL: EXPR_TOKEN = EXPR_TOKEN(0i32);
160 pub const FC_EXPR_CONST32: EXPR_TOKEN = EXPR_TOKEN(1i32);
161 pub const FC_EXPR_CONST64: EXPR_TOKEN = EXPR_TOKEN(2i32);
162 pub const FC_EXPR_VAR: EXPR_TOKEN = EXPR_TOKEN(3i32);
163 pub const FC_EXPR_OPER: EXPR_TOKEN = EXPR_TOKEN(4i32);
164 pub const FC_EXPR_NOOP: EXPR_TOKEN = EXPR_TOKEN(5i32);
165 pub const FC_EXPR_END: EXPR_TOKEN = EXPR_TOKEN(6i32);
166 impl ::std::convert::From<i32> for EXPR_TOKEN {
from(value: i32) -> Self167     fn from(value: i32) -> Self {
168         Self(value)
169     }
170 }
171 unsafe impl ::windows::runtime::Abi for EXPR_TOKEN {
172     type Abi = Self;
173     type DefaultType = Self;
174 }
175 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
176 #[repr(transparent)]
177 pub struct ExtendedErrorParamTypes(pub i32);
178 pub const eeptAnsiString: ExtendedErrorParamTypes = ExtendedErrorParamTypes(1i32);
179 pub const eeptUnicodeString: ExtendedErrorParamTypes = ExtendedErrorParamTypes(2i32);
180 pub const eeptLongVal: ExtendedErrorParamTypes = ExtendedErrorParamTypes(3i32);
181 pub const eeptShortVal: ExtendedErrorParamTypes = ExtendedErrorParamTypes(4i32);
182 pub const eeptPointerVal: ExtendedErrorParamTypes = ExtendedErrorParamTypes(5i32);
183 pub const eeptNone: ExtendedErrorParamTypes = ExtendedErrorParamTypes(6i32);
184 pub const eeptBinary: ExtendedErrorParamTypes = ExtendedErrorParamTypes(7i32);
185 impl ::std::convert::From<i32> for ExtendedErrorParamTypes {
from(value: i32) -> Self186     fn from(value: i32) -> Self {
187         Self(value)
188     }
189 }
190 unsafe impl ::windows::runtime::Abi for ExtendedErrorParamTypes {
191     type Abi = Self;
192     type DefaultType = Self;
193 }
194 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
195 #[repr(C)]
196 pub struct FULL_PTR_XLAT_TABLES {
197     pub RefIdToPointer: *mut ::std::ffi::c_void,
198     pub PointerToRefId: *mut ::std::ffi::c_void,
199     pub NextRefId: u32,
200     pub XlatSide: XLAT_SIDE,
201 }
202 impl FULL_PTR_XLAT_TABLES {}
203 impl ::std::default::Default for FULL_PTR_XLAT_TABLES {
default() -> Self204     fn default() -> Self {
205         unsafe { ::std::mem::zeroed() }
206     }
207 }
208 impl ::std::fmt::Debug for FULL_PTR_XLAT_TABLES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result209     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
210         fmt.debug_struct("FULL_PTR_XLAT_TABLES").field("RefIdToPointer", &self.RefIdToPointer).field("PointerToRefId", &self.PointerToRefId).field("NextRefId", &self.NextRefId).field("XlatSide", &self.XlatSide).finish()
211     }
212 }
213 impl ::std::cmp::PartialEq for FULL_PTR_XLAT_TABLES {
eq(&self, other: &Self) -> bool214     fn eq(&self, other: &Self) -> bool {
215         self.RefIdToPointer == other.RefIdToPointer && self.PointerToRefId == other.PointerToRefId && self.NextRefId == other.NextRefId && self.XlatSide == other.XlatSide
216     }
217 }
218 impl ::std::cmp::Eq for FULL_PTR_XLAT_TABLES {}
219 unsafe impl ::windows::runtime::Abi for FULL_PTR_XLAT_TABLES {
220     type Abi = Self;
221     type DefaultType = Self;
222 }
223 #[derive(:: std :: clone :: Clone)]
224 #[repr(C)]
225 pub struct GENERIC_BINDING_INFO {
226     pub pObj: *mut ::std::ffi::c_void,
227     pub Size: u32,
228     pub pfnBind: ::std::option::Option<GENERIC_BINDING_ROUTINE>,
229     pub pfnUnbind: ::std::option::Option<GENERIC_UNBIND_ROUTINE>,
230 }
231 impl GENERIC_BINDING_INFO {}
232 impl ::std::default::Default for GENERIC_BINDING_INFO {
default() -> Self233     fn default() -> Self {
234         unsafe { ::std::mem::zeroed() }
235     }
236 }
237 impl ::std::fmt::Debug for GENERIC_BINDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result238     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
239         fmt.debug_struct("GENERIC_BINDING_INFO").field("pObj", &self.pObj).field("Size", &self.Size).finish()
240     }
241 }
242 impl ::std::cmp::PartialEq for GENERIC_BINDING_INFO {
eq(&self, other: &Self) -> bool243     fn eq(&self, other: &Self) -> bool {
244         self.pObj == other.pObj && self.Size == other.Size && self.pfnBind.map(|f| f as usize) == other.pfnBind.map(|f| f as usize) && self.pfnUnbind.map(|f| f as usize) == other.pfnUnbind.map(|f| f as usize)
245     }
246 }
247 impl ::std::cmp::Eq for GENERIC_BINDING_INFO {}
248 unsafe impl ::windows::runtime::Abi for GENERIC_BINDING_INFO {
249     type Abi = ::std::mem::ManuallyDrop<Self>;
250     type DefaultType = Self;
251 }
252 pub type GENERIC_BINDING_ROUTINE = unsafe extern "system" fn(param0: *mut ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
253 #[derive(:: std :: clone :: Clone)]
254 #[repr(C)]
255 pub struct GENERIC_BINDING_ROUTINE_PAIR {
256     pub pfnBind: ::std::option::Option<GENERIC_BINDING_ROUTINE>,
257     pub pfnUnbind: ::std::option::Option<GENERIC_UNBIND_ROUTINE>,
258 }
259 impl GENERIC_BINDING_ROUTINE_PAIR {}
260 impl ::std::default::Default for GENERIC_BINDING_ROUTINE_PAIR {
default() -> Self261     fn default() -> Self {
262         unsafe { ::std::mem::zeroed() }
263     }
264 }
265 impl ::std::fmt::Debug for GENERIC_BINDING_ROUTINE_PAIR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result266     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
267         fmt.debug_struct("GENERIC_BINDING_ROUTINE_PAIR").finish()
268     }
269 }
270 impl ::std::cmp::PartialEq for GENERIC_BINDING_ROUTINE_PAIR {
eq(&self, other: &Self) -> bool271     fn eq(&self, other: &Self) -> bool {
272         self.pfnBind.map(|f| f as usize) == other.pfnBind.map(|f| f as usize) && self.pfnUnbind.map(|f| f as usize) == other.pfnUnbind.map(|f| f as usize)
273     }
274 }
275 impl ::std::cmp::Eq for GENERIC_BINDING_ROUTINE_PAIR {}
276 unsafe impl ::windows::runtime::Abi for GENERIC_BINDING_ROUTINE_PAIR {
277     type Abi = ::std::mem::ManuallyDrop<Self>;
278     type DefaultType = Self;
279 }
280 pub type GENERIC_UNBIND_ROUTINE = unsafe extern "system" fn(param0: *mut ::std::ffi::c_void, param1: *mut u8);
281 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
282 #[repr(transparent)]
283 pub struct GROUP_NAME_SYNTAX(pub u32);
284 pub const RPC_C_NS_SYNTAX_DEFAULT: GROUP_NAME_SYNTAX = GROUP_NAME_SYNTAX(0u32);
285 pub const RPC_C_NS_SYNTAX_DCE: GROUP_NAME_SYNTAX = GROUP_NAME_SYNTAX(3u32);
286 impl ::std::convert::From<u32> for GROUP_NAME_SYNTAX {
from(value: u32) -> Self287     fn from(value: u32) -> Self {
288         Self(value)
289     }
290 }
291 unsafe impl ::windows::runtime::Abi for GROUP_NAME_SYNTAX {
292     type Abi = Self;
293     type DefaultType = Self;
294 }
295 impl ::std::ops::BitOr for GROUP_NAME_SYNTAX {
296     type Output = Self;
bitor(self, rhs: Self) -> Self297     fn bitor(self, rhs: Self) -> Self {
298         Self(self.0 | rhs.0)
299     }
300 }
301 impl ::std::ops::BitAnd for GROUP_NAME_SYNTAX {
302     type Output = Self;
bitand(self, rhs: Self) -> Self303     fn bitand(self, rhs: Self) -> Self {
304         Self(self.0 & rhs.0)
305     }
306 }
307 impl ::std::ops::BitOrAssign for GROUP_NAME_SYNTAX {
bitor_assign(&mut self, rhs: Self)308     fn bitor_assign(&mut self, rhs: Self) {
309         self.0.bitor_assign(rhs.0)
310     }
311 }
312 impl ::std::ops::BitAndAssign for GROUP_NAME_SYNTAX {
bitand_assign(&mut self, rhs: Self)313     fn bitand_assign(&mut self, rhs: Self) {
314         self.0.bitand_assign(rhs.0)
315     }
316 }
317 impl ::std::ops::Not for GROUP_NAME_SYNTAX {
318     type Output = Self;
not(self) -> Self319     fn not(self) -> Self {
320         Self(self.0.not())
321     }
322 }
323 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
324 #[repr(transparent)]
325 pub struct IDL_CS_CONVERT(pub i32);
326 pub const IDL_CS_NO_CONVERT: IDL_CS_CONVERT = IDL_CS_CONVERT(0i32);
327 pub const IDL_CS_IN_PLACE_CONVERT: IDL_CS_CONVERT = IDL_CS_CONVERT(1i32);
328 pub const IDL_CS_NEW_BUFFER_CONVERT: IDL_CS_CONVERT = IDL_CS_CONVERT(2i32);
329 impl ::std::convert::From<i32> for IDL_CS_CONVERT {
from(value: i32) -> Self330     fn from(value: i32) -> Self {
331         Self(value)
332     }
333 }
334 unsafe impl ::windows::runtime::Abi for IDL_CS_CONVERT {
335     type Abi = Self;
336     type DefaultType = Self;
337 }
338 pub const INVALID_FRAGMENT_ID: u32 = 0u32;
339 #[inline]
IUnknown_AddRef_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0) -> u32340 pub unsafe fn IUnknown_AddRef_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0) -> u32 {
341     #[cfg(windows)]
342     {
343         #[link(name = "windows")]
344         extern "system" {
345             fn IUnknown_AddRef_Proxy(this: ::windows::runtime::RawPtr) -> u32;
346         }
347         ::std::mem::transmute(IUnknown_AddRef_Proxy(this.into_param().abi()))
348     }
349     #[cfg(not(windows))]
350     unimplemented!("Unsupported target OS");
351 }
352 #[inline]
IUnknown_QueryInterface_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0, riid: *const ::windows::runtime::GUID, ppvobject: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>353 pub unsafe fn IUnknown_QueryInterface_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0, riid: *const ::windows::runtime::GUID, ppvobject: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
354     #[cfg(windows)]
355     {
356         #[link(name = "windows")]
357         extern "system" {
358             fn IUnknown_QueryInterface_Proxy(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppvobject: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
359         }
360         IUnknown_QueryInterface_Proxy(this.into_param().abi(), ::std::mem::transmute(riid), ::std::mem::transmute(ppvobject)).ok()
361     }
362     #[cfg(not(windows))]
363     unimplemented!("Unsupported target OS");
364 }
365 #[inline]
IUnknown_Release_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0) -> u32366 pub unsafe fn IUnknown_Release_Proxy<'a, Param0: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(this: Param0) -> u32 {
367     #[cfg(windows)]
368     {
369         #[link(name = "windows")]
370         extern "system" {
371             fn IUnknown_Release_Proxy(this: ::windows::runtime::RawPtr) -> u32;
372         }
373         ::std::mem::transmute(IUnknown_Release_Proxy(this.into_param().abi()))
374     }
375     #[cfg(not(windows))]
376     unimplemented!("Unsupported target OS");
377 }
378 #[inline]
I_RpcAllocate(size: u32) -> *mut ::std::ffi::c_void379 pub unsafe fn I_RpcAllocate(size: u32) -> *mut ::std::ffi::c_void {
380     #[cfg(windows)]
381     {
382         #[link(name = "windows")]
383         extern "system" {
384             fn I_RpcAllocate(size: u32) -> *mut ::std::ffi::c_void;
385         }
386         ::std::mem::transmute(I_RpcAllocate(::std::mem::transmute(size)))
387     }
388     #[cfg(not(windows))]
389     unimplemented!("Unsupported target OS");
390 }
391 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
392 #[inline]
I_RpcAsyncAbortCall(pasync: *const RPC_ASYNC_STATE, exceptioncode: u32) -> RPC_STATUS393 pub unsafe fn I_RpcAsyncAbortCall(pasync: *const RPC_ASYNC_STATE, exceptioncode: u32) -> RPC_STATUS {
394     #[cfg(windows)]
395     {
396         #[link(name = "windows")]
397         extern "system" {
398             fn I_RpcAsyncAbortCall(pasync: *const ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, exceptioncode: u32) -> RPC_STATUS;
399         }
400         ::std::mem::transmute(I_RpcAsyncAbortCall(::std::mem::transmute(pasync), ::std::mem::transmute(exceptioncode)))
401     }
402     #[cfg(not(windows))]
403     unimplemented!("Unsupported target OS");
404 }
405 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
406 #[inline]
I_RpcAsyncSetHandle(message: *const RPC_MESSAGE, pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS407 pub unsafe fn I_RpcAsyncSetHandle(message: *const RPC_MESSAGE, pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS {
408     #[cfg(windows)]
409     {
410         #[link(name = "windows")]
411         extern "system" {
412             fn I_RpcAsyncSetHandle(message: *const RPC_MESSAGE, pasync: *const ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>) -> RPC_STATUS;
413         }
414         ::std::mem::transmute(I_RpcAsyncSetHandle(::std::mem::transmute(message), ::std::mem::transmute(pasync)))
415     }
416     #[cfg(not(windows))]
417     unimplemented!("Unsupported target OS");
418 }
419 #[inline]
I_RpcBindingCopy(sourcebinding: *mut ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS420 pub unsafe fn I_RpcBindingCopy(sourcebinding: *mut ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
421     #[cfg(windows)]
422     {
423         #[link(name = "windows")]
424         extern "system" {
425             fn I_RpcBindingCopy(sourcebinding: *mut ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
426         }
427         ::std::mem::transmute(I_RpcBindingCopy(::std::mem::transmute(sourcebinding), ::std::mem::transmute(destinationbinding)))
428     }
429     #[cfg(not(windows))]
430     unimplemented!("Unsupported target OS");
431 }
432 #[inline]
I_RpcBindingCreateNP(servername: *const u16, servicename: *const u16, networkoptions: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS433 pub unsafe fn I_RpcBindingCreateNP(servername: *const u16, servicename: *const u16, networkoptions: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
434     #[cfg(windows)]
435     {
436         #[link(name = "windows")]
437         extern "system" {
438             fn I_RpcBindingCreateNP(servername: *const u16, servicename: *const u16, networkoptions: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
439         }
440         ::std::mem::transmute(I_RpcBindingCreateNP(::std::mem::transmute(servername), ::std::mem::transmute(servicename), ::std::mem::transmute(networkoptions), ::std::mem::transmute(binding)))
441     }
442     #[cfg(not(windows))]
443     unimplemented!("Unsupported target OS");
444 }
445 #[inline]
I_RpcBindingHandleToAsyncHandle(binding: *mut ::std::ffi::c_void, asynchandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS446 pub unsafe fn I_RpcBindingHandleToAsyncHandle(binding: *mut ::std::ffi::c_void, asynchandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
447     #[cfg(windows)]
448     {
449         #[link(name = "windows")]
450         extern "system" {
451             fn I_RpcBindingHandleToAsyncHandle(binding: *mut ::std::ffi::c_void, asynchandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
452         }
453         ::std::mem::transmute(I_RpcBindingHandleToAsyncHandle(::std::mem::transmute(binding), ::std::mem::transmute(asynchandle)))
454     }
455     #[cfg(not(windows))]
456     unimplemented!("Unsupported target OS");
457 }
458 #[cfg(feature = "Win32_Foundation")]
459 #[inline]
I_RpcBindingInqClientTokenAttributes(binding: *const ::std::ffi::c_void, tokenid: *mut super::super::Foundation::LUID, authenticationid: *mut super::super::Foundation::LUID, modifiedid: *mut super::super::Foundation::LUID) -> RPC_STATUS460 pub unsafe fn I_RpcBindingInqClientTokenAttributes(binding: *const ::std::ffi::c_void, tokenid: *mut super::super::Foundation::LUID, authenticationid: *mut super::super::Foundation::LUID, modifiedid: *mut super::super::Foundation::LUID) -> RPC_STATUS {
461     #[cfg(windows)]
462     {
463         #[link(name = "windows")]
464         extern "system" {
465             fn I_RpcBindingInqClientTokenAttributes(binding: *const ::std::ffi::c_void, tokenid: *mut super::super::Foundation::LUID, authenticationid: *mut super::super::Foundation::LUID, modifiedid: *mut super::super::Foundation::LUID) -> RPC_STATUS;
466         }
467         ::std::mem::transmute(I_RpcBindingInqClientTokenAttributes(::std::mem::transmute(binding), ::std::mem::transmute(tokenid), ::std::mem::transmute(authenticationid), ::std::mem::transmute(modifiedid)))
468     }
469     #[cfg(not(windows))]
470     unimplemented!("Unsupported target OS");
471 }
472 #[inline]
I_RpcBindingInqDynamicEndpointA(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u8) -> RPC_STATUS473 pub unsafe fn I_RpcBindingInqDynamicEndpointA(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u8) -> RPC_STATUS {
474     #[cfg(windows)]
475     {
476         #[link(name = "windows")]
477         extern "system" {
478             fn I_RpcBindingInqDynamicEndpointA(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u8) -> RPC_STATUS;
479         }
480         ::std::mem::transmute(I_RpcBindingInqDynamicEndpointA(::std::mem::transmute(binding), ::std::mem::transmute(dynamicendpoint)))
481     }
482     #[cfg(not(windows))]
483     unimplemented!("Unsupported target OS");
484 }
485 #[inline]
I_RpcBindingInqDynamicEndpointW(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u16) -> RPC_STATUS486 pub unsafe fn I_RpcBindingInqDynamicEndpointW(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u16) -> RPC_STATUS {
487     #[cfg(windows)]
488     {
489         #[link(name = "windows")]
490         extern "system" {
491             fn I_RpcBindingInqDynamicEndpointW(binding: *const ::std::ffi::c_void, dynamicendpoint: *mut *mut u16) -> RPC_STATUS;
492         }
493         ::std::mem::transmute(I_RpcBindingInqDynamicEndpointW(::std::mem::transmute(binding), ::std::mem::transmute(dynamicendpoint)))
494     }
495     #[cfg(not(windows))]
496     unimplemented!("Unsupported target OS");
497 }
498 #[inline]
I_RpcBindingInqLocalClientPID(binding: *mut ::std::ffi::c_void, pid: *mut u32) -> RPC_STATUS499 pub unsafe fn I_RpcBindingInqLocalClientPID(binding: *mut ::std::ffi::c_void, pid: *mut u32) -> RPC_STATUS {
500     #[cfg(windows)]
501     {
502         #[link(name = "windows")]
503         extern "system" {
504             fn I_RpcBindingInqLocalClientPID(binding: *mut ::std::ffi::c_void, pid: *mut u32) -> RPC_STATUS;
505         }
506         ::std::mem::transmute(I_RpcBindingInqLocalClientPID(::std::mem::transmute(binding), ::std::mem::transmute(pid)))
507     }
508     #[cfg(not(windows))]
509     unimplemented!("Unsupported target OS");
510 }
511 #[inline]
I_RpcBindingInqMarshalledTargetInfo(binding: *const ::std::ffi::c_void, marshalledtargetinfosize: *mut u32, marshalledtargetinfo: *mut *mut u8) -> RPC_STATUS512 pub unsafe fn I_RpcBindingInqMarshalledTargetInfo(binding: *const ::std::ffi::c_void, marshalledtargetinfosize: *mut u32, marshalledtargetinfo: *mut *mut u8) -> RPC_STATUS {
513     #[cfg(windows)]
514     {
515         #[link(name = "windows")]
516         extern "system" {
517             fn I_RpcBindingInqMarshalledTargetInfo(binding: *const ::std::ffi::c_void, marshalledtargetinfosize: *mut u32, marshalledtargetinfo: *mut *mut u8) -> RPC_STATUS;
518         }
519         ::std::mem::transmute(I_RpcBindingInqMarshalledTargetInfo(::std::mem::transmute(binding), ::std::mem::transmute(marshalledtargetinfosize), ::std::mem::transmute(marshalledtargetinfo)))
520     }
521     #[cfg(not(windows))]
522     unimplemented!("Unsupported target OS");
523 }
524 #[inline]
I_RpcBindingInqSecurityContext(binding: *mut ::std::ffi::c_void, securitycontexthandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS525 pub unsafe fn I_RpcBindingInqSecurityContext(binding: *mut ::std::ffi::c_void, securitycontexthandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
526     #[cfg(windows)]
527     {
528         #[link(name = "windows")]
529         extern "system" {
530             fn I_RpcBindingInqSecurityContext(binding: *mut ::std::ffi::c_void, securitycontexthandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
531         }
532         ::std::mem::transmute(I_RpcBindingInqSecurityContext(::std::mem::transmute(binding), ::std::mem::transmute(securitycontexthandle)))
533     }
534     #[cfg(not(windows))]
535     unimplemented!("Unsupported target OS");
536 }
537 #[inline]
I_RpcBindingInqSecurityContextKeyInfo(binding: *const ::std::ffi::c_void, keyinfo: *mut ::std::ffi::c_void) -> RPC_STATUS538 pub unsafe fn I_RpcBindingInqSecurityContextKeyInfo(binding: *const ::std::ffi::c_void, keyinfo: *mut ::std::ffi::c_void) -> RPC_STATUS {
539     #[cfg(windows)]
540     {
541         #[link(name = "windows")]
542         extern "system" {
543             fn I_RpcBindingInqSecurityContextKeyInfo(binding: *const ::std::ffi::c_void, keyinfo: *mut ::std::ffi::c_void) -> RPC_STATUS;
544         }
545         ::std::mem::transmute(I_RpcBindingInqSecurityContextKeyInfo(::std::mem::transmute(binding), ::std::mem::transmute(keyinfo)))
546     }
547     #[cfg(not(windows))]
548     unimplemented!("Unsupported target OS");
549 }
550 #[inline]
I_RpcBindingInqTransportType(binding: *mut ::std::ffi::c_void, r#type: *mut u32) -> RPC_STATUS551 pub unsafe fn I_RpcBindingInqTransportType(binding: *mut ::std::ffi::c_void, r#type: *mut u32) -> RPC_STATUS {
552     #[cfg(windows)]
553     {
554         #[link(name = "windows")]
555         extern "system" {
556             fn I_RpcBindingInqTransportType(binding: *mut ::std::ffi::c_void, r#type: *mut u32) -> RPC_STATUS;
557         }
558         ::std::mem::transmute(I_RpcBindingInqTransportType(::std::mem::transmute(binding), ::std::mem::transmute(r#type)))
559     }
560     #[cfg(not(windows))]
561     unimplemented!("Unsupported target OS");
562 }
563 #[inline]
I_RpcBindingInqWireIdForSnego(binding: *const ::std::ffi::c_void, wireid: *mut u8) -> RPC_STATUS564 pub unsafe fn I_RpcBindingInqWireIdForSnego(binding: *const ::std::ffi::c_void, wireid: *mut u8) -> RPC_STATUS {
565     #[cfg(windows)]
566     {
567         #[link(name = "windows")]
568         extern "system" {
569             fn I_RpcBindingInqWireIdForSnego(binding: *const ::std::ffi::c_void, wireid: *mut u8) -> RPC_STATUS;
570         }
571         ::std::mem::transmute(I_RpcBindingInqWireIdForSnego(::std::mem::transmute(binding), ::std::mem::transmute(wireid)))
572     }
573     #[cfg(not(windows))]
574     unimplemented!("Unsupported target OS");
575 }
576 #[inline]
I_RpcBindingIsClientLocal(bindinghandle: *mut ::std::ffi::c_void, clientlocalflag: *mut u32) -> RPC_STATUS577 pub unsafe fn I_RpcBindingIsClientLocal(bindinghandle: *mut ::std::ffi::c_void, clientlocalflag: *mut u32) -> RPC_STATUS {
578     #[cfg(windows)]
579     {
580         #[link(name = "windows")]
581         extern "system" {
582             fn I_RpcBindingIsClientLocal(bindinghandle: *mut ::std::ffi::c_void, clientlocalflag: *mut u32) -> RPC_STATUS;
583         }
584         ::std::mem::transmute(I_RpcBindingIsClientLocal(::std::mem::transmute(bindinghandle), ::std::mem::transmute(clientlocalflag)))
585     }
586     #[cfg(not(windows))]
587     unimplemented!("Unsupported target OS");
588 }
589 #[inline]
I_RpcBindingIsServerLocal(binding: *const ::std::ffi::c_void, serverlocalflag: *mut u32) -> RPC_STATUS590 pub unsafe fn I_RpcBindingIsServerLocal(binding: *const ::std::ffi::c_void, serverlocalflag: *mut u32) -> RPC_STATUS {
591     #[cfg(windows)]
592     {
593         #[link(name = "windows")]
594         extern "system" {
595             fn I_RpcBindingIsServerLocal(binding: *const ::std::ffi::c_void, serverlocalflag: *mut u32) -> RPC_STATUS;
596         }
597         ::std::mem::transmute(I_RpcBindingIsServerLocal(::std::mem::transmute(binding), ::std::mem::transmute(serverlocalflag)))
598     }
599     #[cfg(not(windows))]
600     unimplemented!("Unsupported target OS");
601 }
602 #[inline]
I_RpcBindingSetPrivateOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS603 pub unsafe fn I_RpcBindingSetPrivateOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS {
604     #[cfg(windows)]
605     {
606         #[link(name = "windows")]
607         extern "system" {
608             fn I_RpcBindingSetPrivateOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS;
609         }
610         ::std::mem::transmute(I_RpcBindingSetPrivateOption(::std::mem::transmute(hbinding), ::std::mem::transmute(option), ::std::mem::transmute(optionvalue)))
611     }
612     #[cfg(not(windows))]
613     unimplemented!("Unsupported target OS");
614 }
615 #[inline]
I_RpcBindingToStaticStringBindingW(binding: *mut ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS616 pub unsafe fn I_RpcBindingToStaticStringBindingW(binding: *mut ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS {
617     #[cfg(windows)]
618     {
619         #[link(name = "windows")]
620         extern "system" {
621             fn I_RpcBindingToStaticStringBindingW(binding: *mut ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS;
622         }
623         ::std::mem::transmute(I_RpcBindingToStaticStringBindingW(::std::mem::transmute(binding), ::std::mem::transmute(stringbinding)))
624     }
625     #[cfg(not(windows))]
626     unimplemented!("Unsupported target OS");
627 }
628 #[inline]
I_RpcClearMutex(mutex: *mut ::std::ffi::c_void)629 pub unsafe fn I_RpcClearMutex(mutex: *mut ::std::ffi::c_void) {
630     #[cfg(windows)]
631     {
632         #[link(name = "windows")]
633         extern "system" {
634             fn I_RpcClearMutex(mutex: *mut ::std::ffi::c_void);
635         }
636         ::std::mem::transmute(I_RpcClearMutex(::std::mem::transmute(mutex)))
637     }
638     #[cfg(not(windows))]
639     unimplemented!("Unsupported target OS");
640 }
641 #[inline]
I_RpcDeleteMutex(mutex: *mut ::std::ffi::c_void)642 pub unsafe fn I_RpcDeleteMutex(mutex: *mut ::std::ffi::c_void) {
643     #[cfg(windows)]
644     {
645         #[link(name = "windows")]
646         extern "system" {
647             fn I_RpcDeleteMutex(mutex: *mut ::std::ffi::c_void);
648         }
649         ::std::mem::transmute(I_RpcDeleteMutex(::std::mem::transmute(mutex)))
650     }
651     #[cfg(not(windows))]
652     unimplemented!("Unsupported target OS");
653 }
654 #[inline]
I_RpcExceptionFilter(exceptioncode: u32) -> i32655 pub unsafe fn I_RpcExceptionFilter(exceptioncode: u32) -> i32 {
656     #[cfg(windows)]
657     {
658         #[link(name = "windows")]
659         extern "system" {
660             fn I_RpcExceptionFilter(exceptioncode: u32) -> i32;
661         }
662         ::std::mem::transmute(I_RpcExceptionFilter(::std::mem::transmute(exceptioncode)))
663     }
664     #[cfg(not(windows))]
665     unimplemented!("Unsupported target OS");
666 }
667 #[inline]
I_RpcFree(object: *mut ::std::ffi::c_void)668 pub unsafe fn I_RpcFree(object: *mut ::std::ffi::c_void) {
669     #[cfg(windows)]
670     {
671         #[link(name = "windows")]
672         extern "system" {
673             fn I_RpcFree(object: *mut ::std::ffi::c_void);
674         }
675         ::std::mem::transmute(I_RpcFree(::std::mem::transmute(object)))
676     }
677     #[cfg(not(windows))]
678     unimplemented!("Unsupported target OS");
679 }
680 #[inline]
I_RpcFreeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS681 pub unsafe fn I_RpcFreeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS {
682     #[cfg(windows)]
683     {
684         #[link(name = "windows")]
685         extern "system" {
686             fn I_RpcFreeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS;
687         }
688         ::std::mem::transmute(I_RpcFreeBuffer(::std::mem::transmute(message)))
689     }
690     #[cfg(not(windows))]
691     unimplemented!("Unsupported target OS");
692 }
693 pub type I_RpcFreeCalloutStateFn = unsafe extern "system" fn(calloutstate: *mut RDR_CALLOUT_STATE);
694 #[inline]
I_RpcFreePipeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS695 pub unsafe fn I_RpcFreePipeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS {
696     #[cfg(windows)]
697     {
698         #[link(name = "windows")]
699         extern "system" {
700             fn I_RpcFreePipeBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS;
701         }
702         ::std::mem::transmute(I_RpcFreePipeBuffer(::std::mem::transmute(message)))
703     }
704     #[cfg(not(windows))]
705     unimplemented!("Unsupported target OS");
706 }
707 #[inline]
I_RpcGetBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS708 pub unsafe fn I_RpcGetBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS {
709     #[cfg(windows)]
710     {
711         #[link(name = "windows")]
712         extern "system" {
713             fn I_RpcGetBuffer(message: *mut RPC_MESSAGE) -> RPC_STATUS;
714         }
715         ::std::mem::transmute(I_RpcGetBuffer(::std::mem::transmute(message)))
716     }
717     #[cfg(not(windows))]
718     unimplemented!("Unsupported target OS");
719 }
720 #[inline]
I_RpcGetBufferWithObject(message: *mut RPC_MESSAGE, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS721 pub unsafe fn I_RpcGetBufferWithObject(message: *mut RPC_MESSAGE, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
722     #[cfg(windows)]
723     {
724         #[link(name = "windows")]
725         extern "system" {
726             fn I_RpcGetBufferWithObject(message: *mut RPC_MESSAGE, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
727         }
728         ::std::mem::transmute(I_RpcGetBufferWithObject(::std::mem::transmute(message), ::std::mem::transmute(objectuuid)))
729     }
730     #[cfg(not(windows))]
731     unimplemented!("Unsupported target OS");
732 }
733 #[inline]
I_RpcGetCurrentCallHandle() -> *mut ::std::ffi::c_void734 pub unsafe fn I_RpcGetCurrentCallHandle() -> *mut ::std::ffi::c_void {
735     #[cfg(windows)]
736     {
737         #[link(name = "windows")]
738         extern "system" {
739             fn I_RpcGetCurrentCallHandle() -> *mut ::std::ffi::c_void;
740         }
741         ::std::mem::transmute(I_RpcGetCurrentCallHandle())
742     }
743     #[cfg(not(windows))]
744     unimplemented!("Unsupported target OS");
745 }
746 #[inline]
I_RpcGetDefaultSD(ppsecuritydescriptor: *mut *mut ::std::ffi::c_void) -> RPC_STATUS747 pub unsafe fn I_RpcGetDefaultSD(ppsecuritydescriptor: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
748     #[cfg(windows)]
749     {
750         #[link(name = "windows")]
751         extern "system" {
752             fn I_RpcGetDefaultSD(ppsecuritydescriptor: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
753         }
754         ::std::mem::transmute(I_RpcGetDefaultSD(::std::mem::transmute(ppsecuritydescriptor)))
755     }
756     #[cfg(not(windows))]
757     unimplemented!("Unsupported target OS");
758 }
759 #[inline]
I_RpcGetExtendedError() -> RPC_STATUS760 pub unsafe fn I_RpcGetExtendedError() -> RPC_STATUS {
761     #[cfg(windows)]
762     {
763         #[link(name = "windows")]
764         extern "system" {
765             fn I_RpcGetExtendedError() -> RPC_STATUS;
766         }
767         ::std::mem::transmute(I_RpcGetExtendedError())
768     }
769     #[cfg(not(windows))]
770     unimplemented!("Unsupported target OS");
771 }
772 #[inline]
I_RpcIfInqTransferSyntaxes(rpcifhandle: *mut ::std::ffi::c_void, transfersyntaxes: *mut RPC_TRANSFER_SYNTAX, transfersyntaxsize: u32, transfersyntaxcount: *mut u32) -> RPC_STATUS773 pub unsafe fn I_RpcIfInqTransferSyntaxes(rpcifhandle: *mut ::std::ffi::c_void, transfersyntaxes: *mut RPC_TRANSFER_SYNTAX, transfersyntaxsize: u32, transfersyntaxcount: *mut u32) -> RPC_STATUS {
774     #[cfg(windows)]
775     {
776         #[link(name = "windows")]
777         extern "system" {
778             fn I_RpcIfInqTransferSyntaxes(rpcifhandle: *mut ::std::ffi::c_void, transfersyntaxes: *mut RPC_TRANSFER_SYNTAX, transfersyntaxsize: u32, transfersyntaxcount: *mut u32) -> RPC_STATUS;
779         }
780         ::std::mem::transmute(I_RpcIfInqTransferSyntaxes(::std::mem::transmute(rpcifhandle), ::std::mem::transmute(transfersyntaxes), ::std::mem::transmute(transfersyntaxsize), ::std::mem::transmute(transfersyntaxcount)))
781     }
782     #[cfg(not(windows))]
783     unimplemented!("Unsupported target OS");
784 }
785 #[inline]
I_RpcMapWin32Status(status: RPC_STATUS) -> i32786 pub unsafe fn I_RpcMapWin32Status(status: RPC_STATUS) -> i32 {
787     #[cfg(windows)]
788     {
789         #[link(name = "windows")]
790         extern "system" {
791             fn I_RpcMapWin32Status(status: RPC_STATUS) -> i32;
792         }
793         ::std::mem::transmute(I_RpcMapWin32Status(::std::mem::transmute(status)))
794     }
795     #[cfg(not(windows))]
796     unimplemented!("Unsupported target OS");
797 }
798 #[inline]
I_RpcMgmtEnableDedicatedThreadPool() -> RPC_STATUS799 pub unsafe fn I_RpcMgmtEnableDedicatedThreadPool() -> RPC_STATUS {
800     #[cfg(windows)]
801     {
802         #[link(name = "windows")]
803         extern "system" {
804             fn I_RpcMgmtEnableDedicatedThreadPool() -> RPC_STATUS;
805         }
806         ::std::mem::transmute(I_RpcMgmtEnableDedicatedThreadPool())
807     }
808     #[cfg(not(windows))]
809     unimplemented!("Unsupported target OS");
810 }
811 #[inline]
I_RpcNegotiateTransferSyntax(message: *mut RPC_MESSAGE) -> RPC_STATUS812 pub unsafe fn I_RpcNegotiateTransferSyntax(message: *mut RPC_MESSAGE) -> RPC_STATUS {
813     #[cfg(windows)]
814     {
815         #[link(name = "windows")]
816         extern "system" {
817             fn I_RpcNegotiateTransferSyntax(message: *mut RPC_MESSAGE) -> RPC_STATUS;
818         }
819         ::std::mem::transmute(I_RpcNegotiateTransferSyntax(::std::mem::transmute(message)))
820     }
821     #[cfg(not(windows))]
822     unimplemented!("Unsupported target OS");
823 }
824 #[inline]
I_RpcNsBindingSetEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS825 pub unsafe fn I_RpcNsBindingSetEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS {
826     #[cfg(windows)]
827     {
828         #[link(name = "windows")]
829         extern "system" {
830             fn I_RpcNsBindingSetEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS;
831         }
832         ::std::mem::transmute(I_RpcNsBindingSetEntryNameA(::std::mem::transmute(binding), ::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
833     }
834     #[cfg(not(windows))]
835     unimplemented!("Unsupported target OS");
836 }
837 #[inline]
I_RpcNsBindingSetEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS838 pub unsafe fn I_RpcNsBindingSetEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS {
839     #[cfg(windows)]
840     {
841         #[link(name = "windows")]
842         extern "system" {
843             fn I_RpcNsBindingSetEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS;
844         }
845         ::std::mem::transmute(I_RpcNsBindingSetEntryNameW(::std::mem::transmute(binding), ::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
846     }
847     #[cfg(not(windows))]
848     unimplemented!("Unsupported target OS");
849 }
850 #[inline]
I_RpcNsInterfaceExported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS851 pub unsafe fn I_RpcNsInterfaceExported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS {
852     #[cfg(windows)]
853     {
854         #[link(name = "windows")]
855         extern "system" {
856             fn I_RpcNsInterfaceExported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS;
857         }
858         ::std::mem::transmute(I_RpcNsInterfaceExported(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(rpcinterfaceinformation)))
859     }
860     #[cfg(not(windows))]
861     unimplemented!("Unsupported target OS");
862 }
863 #[inline]
I_RpcNsInterfaceUnexported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS864 pub unsafe fn I_RpcNsInterfaceUnexported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS {
865     #[cfg(windows)]
866     {
867         #[link(name = "windows")]
868         extern "system" {
869             fn I_RpcNsInterfaceUnexported(entrynamesyntax: u32, entryname: *mut u16, rpcinterfaceinformation: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS;
870         }
871         ::std::mem::transmute(I_RpcNsInterfaceUnexported(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(rpcinterfaceinformation)))
872     }
873     #[cfg(not(windows))]
874     unimplemented!("Unsupported target OS");
875 }
876 #[inline]
I_RpcOpenClientProcess(binding: *const ::std::ffi::c_void, desiredaccess: u32, clientprocess: *mut *mut ::std::ffi::c_void) -> RPC_STATUS877 pub unsafe fn I_RpcOpenClientProcess(binding: *const ::std::ffi::c_void, desiredaccess: u32, clientprocess: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
878     #[cfg(windows)]
879     {
880         #[link(name = "windows")]
881         extern "system" {
882             fn I_RpcOpenClientProcess(binding: *const ::std::ffi::c_void, desiredaccess: u32, clientprocess: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
883         }
884         ::std::mem::transmute(I_RpcOpenClientProcess(::std::mem::transmute(binding), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(clientprocess)))
885     }
886     #[cfg(not(windows))]
887     unimplemented!("Unsupported target OS");
888 }
889 #[inline]
I_RpcPauseExecution(milliseconds: u32)890 pub unsafe fn I_RpcPauseExecution(milliseconds: u32) {
891     #[cfg(windows)]
892     {
893         #[link(name = "windows")]
894         extern "system" {
895             fn I_RpcPauseExecution(milliseconds: u32);
896         }
897         ::std::mem::transmute(I_RpcPauseExecution(::std::mem::transmute(milliseconds)))
898     }
899     #[cfg(not(windows))]
900     unimplemented!("Unsupported target OS");
901 }
902 pub type I_RpcPerformCalloutFn = unsafe extern "system" fn(context: *mut ::std::ffi::c_void, calloutstate: *mut RDR_CALLOUT_STATE, stage: RPC_HTTP_REDIRECTOR_STAGE) -> RPC_STATUS;
903 #[derive(:: std :: clone :: Clone)]
904 #[repr(C)]
905 #[cfg(feature = "Win32_Foundation")]
906 pub struct I_RpcProxyCallbackInterface {
907     pub IsValidMachineFn: ::std::option::Option<I_RpcProxyIsValidMachineFn>,
908     pub GetClientAddressFn: ::std::option::Option<I_RpcProxyGetClientAddressFn>,
909     pub GetConnectionTimeoutFn: ::std::option::Option<I_RpcProxyGetConnectionTimeoutFn>,
910     pub PerformCalloutFn: ::std::option::Option<I_RpcPerformCalloutFn>,
911     pub FreeCalloutStateFn: ::std::option::Option<I_RpcFreeCalloutStateFn>,
912     pub GetClientSessionAndResourceUUIDFn: ::std::option::Option<I_RpcProxyGetClientSessionAndResourceUUID>,
913     pub ProxyFilterIfFn: ::std::option::Option<I_RpcProxyFilterIfFn>,
914     pub RpcProxyUpdatePerfCounterFn: ::std::option::Option<I_RpcProxyUpdatePerfCounterFn>,
915     pub RpcProxyUpdatePerfCounterBackendServerFn: ::std::option::Option<I_RpcProxyUpdatePerfCounterBackendServerFn>,
916 }
917 #[cfg(feature = "Win32_Foundation")]
918 impl I_RpcProxyCallbackInterface {}
919 #[cfg(feature = "Win32_Foundation")]
920 impl ::std::default::Default for I_RpcProxyCallbackInterface {
default() -> Self921     fn default() -> Self {
922         unsafe { ::std::mem::zeroed() }
923     }
924 }
925 #[cfg(feature = "Win32_Foundation")]
926 impl ::std::fmt::Debug for I_RpcProxyCallbackInterface {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result927     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
928         fmt.debug_struct("I_RpcProxyCallbackInterface").finish()
929     }
930 }
931 #[cfg(feature = "Win32_Foundation")]
932 impl ::std::cmp::PartialEq for I_RpcProxyCallbackInterface {
eq(&self, other: &Self) -> bool933     fn eq(&self, other: &Self) -> bool {
934         self.IsValidMachineFn.map(|f| f as usize) == other.IsValidMachineFn.map(|f| f as usize)
935             && self.GetClientAddressFn.map(|f| f as usize) == other.GetClientAddressFn.map(|f| f as usize)
936             && self.GetConnectionTimeoutFn.map(|f| f as usize) == other.GetConnectionTimeoutFn.map(|f| f as usize)
937             && self.PerformCalloutFn.map(|f| f as usize) == other.PerformCalloutFn.map(|f| f as usize)
938             && self.FreeCalloutStateFn.map(|f| f as usize) == other.FreeCalloutStateFn.map(|f| f as usize)
939             && self.GetClientSessionAndResourceUUIDFn.map(|f| f as usize) == other.GetClientSessionAndResourceUUIDFn.map(|f| f as usize)
940             && self.ProxyFilterIfFn.map(|f| f as usize) == other.ProxyFilterIfFn.map(|f| f as usize)
941             && self.RpcProxyUpdatePerfCounterFn.map(|f| f as usize) == other.RpcProxyUpdatePerfCounterFn.map(|f| f as usize)
942             && self.RpcProxyUpdatePerfCounterBackendServerFn.map(|f| f as usize) == other.RpcProxyUpdatePerfCounterBackendServerFn.map(|f| f as usize)
943     }
944 }
945 #[cfg(feature = "Win32_Foundation")]
946 impl ::std::cmp::Eq for I_RpcProxyCallbackInterface {}
947 #[cfg(feature = "Win32_Foundation")]
948 unsafe impl ::windows::runtime::Abi for I_RpcProxyCallbackInterface {
949     type Abi = ::std::mem::ManuallyDrop<Self>;
950     type DefaultType = Self;
951 }
952 pub type I_RpcProxyFilterIfFn = unsafe extern "system" fn(context: *const ::std::ffi::c_void, ifuuid: *const ::windows::runtime::GUID, ifmajorversion: u16, fallow: *mut i32) -> RPC_STATUS;
953 #[cfg(feature = "Win32_Foundation")]
954 pub type I_RpcProxyGetClientAddressFn = unsafe extern "system" fn(context: *mut ::std::ffi::c_void, buffer: super::super::Foundation::PSTR, bufferlength: *mut u32) -> RPC_STATUS;
955 pub type I_RpcProxyGetClientSessionAndResourceUUID = unsafe extern "system" fn(context: *const ::std::ffi::c_void, sessionidpresent: *mut i32, sessionid: *mut ::windows::runtime::GUID, resourceidpresent: *mut i32, resourceid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
956 pub type I_RpcProxyGetConnectionTimeoutFn = unsafe extern "system" fn(connectiontimeout: *mut u32) -> RPC_STATUS;
957 pub type I_RpcProxyIsValidMachineFn = unsafe extern "system" fn(machine: *const u16, dotmachine: *const u16, portnumber: u32) -> RPC_STATUS;
958 pub type I_RpcProxyUpdatePerfCounterBackendServerFn = unsafe extern "system" fn(machinename: *const u16, isconnectevent: i32);
959 pub type I_RpcProxyUpdatePerfCounterFn = unsafe extern "system" fn(counter: RpcProxyPerfCounters, modifytrend: i32, size: u32);
960 #[inline]
I_RpcReallocPipeBuffer(message: *const RPC_MESSAGE, newsize: u32) -> RPC_STATUS961 pub unsafe fn I_RpcReallocPipeBuffer(message: *const RPC_MESSAGE, newsize: u32) -> RPC_STATUS {
962     #[cfg(windows)]
963     {
964         #[link(name = "windows")]
965         extern "system" {
966             fn I_RpcReallocPipeBuffer(message: *const RPC_MESSAGE, newsize: u32) -> RPC_STATUS;
967         }
968         ::std::mem::transmute(I_RpcReallocPipeBuffer(::std::mem::transmute(message), ::std::mem::transmute(newsize)))
969     }
970     #[cfg(not(windows))]
971     unimplemented!("Unsupported target OS");
972 }
973 #[inline]
I_RpcReceive(message: *mut RPC_MESSAGE, size: u32) -> RPC_STATUS974 pub unsafe fn I_RpcReceive(message: *mut RPC_MESSAGE, size: u32) -> RPC_STATUS {
975     #[cfg(windows)]
976     {
977         #[link(name = "windows")]
978         extern "system" {
979             fn I_RpcReceive(message: *mut RPC_MESSAGE, size: u32) -> RPC_STATUS;
980         }
981         ::std::mem::transmute(I_RpcReceive(::std::mem::transmute(message), ::std::mem::transmute(size)))
982     }
983     #[cfg(not(windows))]
984     unimplemented!("Unsupported target OS");
985 }
986 #[inline]
I_RpcRecordCalloutFailure(rpcstatus: RPC_STATUS, calloutstate: *mut RDR_CALLOUT_STATE, dllname: *mut u16)987 pub unsafe fn I_RpcRecordCalloutFailure(rpcstatus: RPC_STATUS, calloutstate: *mut RDR_CALLOUT_STATE, dllname: *mut u16) {
988     #[cfg(windows)]
989     {
990         #[link(name = "windows")]
991         extern "system" {
992             fn I_RpcRecordCalloutFailure(rpcstatus: RPC_STATUS, calloutstate: *mut RDR_CALLOUT_STATE, dllname: *mut u16);
993         }
994         ::std::mem::transmute(I_RpcRecordCalloutFailure(::std::mem::transmute(rpcstatus), ::std::mem::transmute(calloutstate), ::std::mem::transmute(dllname)))
995     }
996     #[cfg(not(windows))]
997     unimplemented!("Unsupported target OS");
998 }
999 #[inline]
I_RpcRequestMutex(mutex: *mut *mut ::std::ffi::c_void)1000 pub unsafe fn I_RpcRequestMutex(mutex: *mut *mut ::std::ffi::c_void) {
1001     #[cfg(windows)]
1002     {
1003         #[link(name = "windows")]
1004         extern "system" {
1005             fn I_RpcRequestMutex(mutex: *mut *mut ::std::ffi::c_void);
1006         }
1007         ::std::mem::transmute(I_RpcRequestMutex(::std::mem::transmute(mutex)))
1008     }
1009     #[cfg(not(windows))]
1010     unimplemented!("Unsupported target OS");
1011 }
1012 #[inline]
I_RpcSend(message: *mut RPC_MESSAGE) -> RPC_STATUS1013 pub unsafe fn I_RpcSend(message: *mut RPC_MESSAGE) -> RPC_STATUS {
1014     #[cfg(windows)]
1015     {
1016         #[link(name = "windows")]
1017         extern "system" {
1018             fn I_RpcSend(message: *mut RPC_MESSAGE) -> RPC_STATUS;
1019         }
1020         ::std::mem::transmute(I_RpcSend(::std::mem::transmute(message)))
1021     }
1022     #[cfg(not(windows))]
1023     unimplemented!("Unsupported target OS");
1024 }
1025 #[inline]
I_RpcSendReceive(message: *mut RPC_MESSAGE) -> RPC_STATUS1026 pub unsafe fn I_RpcSendReceive(message: *mut RPC_MESSAGE) -> RPC_STATUS {
1027     #[cfg(windows)]
1028     {
1029         #[link(name = "windows")]
1030         extern "system" {
1031             fn I_RpcSendReceive(message: *mut RPC_MESSAGE) -> RPC_STATUS;
1032         }
1033         ::std::mem::transmute(I_RpcSendReceive(::std::mem::transmute(message)))
1034     }
1035     #[cfg(not(windows))]
1036     unimplemented!("Unsupported target OS");
1037 }
1038 #[inline]
I_RpcServerCheckClientRestriction(context: *mut ::std::ffi::c_void) -> RPC_STATUS1039 pub unsafe fn I_RpcServerCheckClientRestriction(context: *mut ::std::ffi::c_void) -> RPC_STATUS {
1040     #[cfg(windows)]
1041     {
1042         #[link(name = "windows")]
1043         extern "system" {
1044             fn I_RpcServerCheckClientRestriction(context: *mut ::std::ffi::c_void) -> RPC_STATUS;
1045         }
1046         ::std::mem::transmute(I_RpcServerCheckClientRestriction(::std::mem::transmute(context)))
1047     }
1048     #[cfg(not(windows))]
1049     unimplemented!("Unsupported target OS");
1050 }
1051 #[inline]
I_RpcServerDisableExceptionFilter() -> i321052 pub unsafe fn I_RpcServerDisableExceptionFilter() -> i32 {
1053     #[cfg(windows)]
1054     {
1055         #[link(name = "windows")]
1056         extern "system" {
1057             fn I_RpcServerDisableExceptionFilter() -> i32;
1058         }
1059         ::std::mem::transmute(I_RpcServerDisableExceptionFilter())
1060     }
1061     #[cfg(not(windows))]
1062     unimplemented!("Unsupported target OS");
1063 }
1064 #[inline]
I_RpcServerGetAssociationID(binding: *const ::std::ffi::c_void, associationid: *mut u32) -> RPC_STATUS1065 pub unsafe fn I_RpcServerGetAssociationID(binding: *const ::std::ffi::c_void, associationid: *mut u32) -> RPC_STATUS {
1066     #[cfg(windows)]
1067     {
1068         #[link(name = "windows")]
1069         extern "system" {
1070             fn I_RpcServerGetAssociationID(binding: *const ::std::ffi::c_void, associationid: *mut u32) -> RPC_STATUS;
1071         }
1072         ::std::mem::transmute(I_RpcServerGetAssociationID(::std::mem::transmute(binding), ::std::mem::transmute(associationid)))
1073     }
1074     #[cfg(not(windows))]
1075     unimplemented!("Unsupported target OS");
1076 }
1077 #[inline]
I_RpcServerInqAddressChangeFn() -> *mut ::std::option::Option<RPC_ADDRESS_CHANGE_FN>1078 pub unsafe fn I_RpcServerInqAddressChangeFn() -> *mut ::std::option::Option<RPC_ADDRESS_CHANGE_FN> {
1079     #[cfg(windows)]
1080     {
1081         #[link(name = "windows")]
1082         extern "system" {
1083             fn I_RpcServerInqAddressChangeFn() -> *mut ::std::option::Option<RPC_ADDRESS_CHANGE_FN>;
1084         }
1085         ::std::mem::transmute(I_RpcServerInqAddressChangeFn())
1086     }
1087     #[cfg(not(windows))]
1088     unimplemented!("Unsupported target OS");
1089 }
1090 #[inline]
I_RpcServerInqLocalConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS1091 pub unsafe fn I_RpcServerInqLocalConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS {
1092     #[cfg(windows)]
1093     {
1094         #[link(name = "windows")]
1095         extern "system" {
1096             fn I_RpcServerInqLocalConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS;
1097         }
1098         ::std::mem::transmute(I_RpcServerInqLocalConnAddress(::std::mem::transmute(binding), ::std::mem::transmute(buffer), ::std::mem::transmute(buffersize), ::std::mem::transmute(addressformat)))
1099     }
1100     #[cfg(not(windows))]
1101     unimplemented!("Unsupported target OS");
1102 }
1103 #[inline]
I_RpcServerInqRemoteConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS1104 pub unsafe fn I_RpcServerInqRemoteConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS {
1105     #[cfg(windows)]
1106     {
1107         #[link(name = "windows")]
1108         extern "system" {
1109             fn I_RpcServerInqRemoteConnAddress(binding: *mut ::std::ffi::c_void, buffer: *mut ::std::ffi::c_void, buffersize: *mut u32, addressformat: *mut u32) -> RPC_STATUS;
1110         }
1111         ::std::mem::transmute(I_RpcServerInqRemoteConnAddress(::std::mem::transmute(binding), ::std::mem::transmute(buffer), ::std::mem::transmute(buffersize), ::std::mem::transmute(addressformat)))
1112     }
1113     #[cfg(not(windows))]
1114     unimplemented!("Unsupported target OS");
1115 }
1116 #[inline]
I_RpcServerInqTransportType(r#type: *mut u32) -> RPC_STATUS1117 pub unsafe fn I_RpcServerInqTransportType(r#type: *mut u32) -> RPC_STATUS {
1118     #[cfg(windows)]
1119     {
1120         #[link(name = "windows")]
1121         extern "system" {
1122             fn I_RpcServerInqTransportType(r#type: *mut u32) -> RPC_STATUS;
1123         }
1124         ::std::mem::transmute(I_RpcServerInqTransportType(::std::mem::transmute(r#type)))
1125     }
1126     #[cfg(not(windows))]
1127     unimplemented!("Unsupported target OS");
1128 }
1129 #[inline]
I_RpcServerRegisterForwardFunction(pforwardfunction: *mut ::std::option::Option<RPC_FORWARD_FUNCTION>) -> RPC_STATUS1130 pub unsafe fn I_RpcServerRegisterForwardFunction(pforwardfunction: *mut ::std::option::Option<RPC_FORWARD_FUNCTION>) -> RPC_STATUS {
1131     #[cfg(windows)]
1132     {
1133         #[link(name = "windows")]
1134         extern "system" {
1135             fn I_RpcServerRegisterForwardFunction(pforwardfunction: *mut ::windows::runtime::RawPtr) -> RPC_STATUS;
1136         }
1137         ::std::mem::transmute(I_RpcServerRegisterForwardFunction(::std::mem::transmute(pforwardfunction)))
1138     }
1139     #[cfg(not(windows))]
1140     unimplemented!("Unsupported target OS");
1141 }
1142 #[inline]
I_RpcServerSetAddressChangeFn(paddresschangefn: *mut ::std::option::Option<RPC_ADDRESS_CHANGE_FN>) -> RPC_STATUS1143 pub unsafe fn I_RpcServerSetAddressChangeFn(paddresschangefn: *mut ::std::option::Option<RPC_ADDRESS_CHANGE_FN>) -> RPC_STATUS {
1144     #[cfg(windows)]
1145     {
1146         #[link(name = "windows")]
1147         extern "system" {
1148             fn I_RpcServerSetAddressChangeFn(paddresschangefn: *mut ::windows::runtime::RawPtr) -> RPC_STATUS;
1149         }
1150         ::std::mem::transmute(I_RpcServerSetAddressChangeFn(::std::mem::transmute(paddresschangefn)))
1151     }
1152     #[cfg(not(windows))]
1153     unimplemented!("Unsupported target OS");
1154 }
1155 #[inline]
I_RpcServerStartService(protseq: *const u16, endpoint: *const u16, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS1156 pub unsafe fn I_RpcServerStartService(protseq: *const u16, endpoint: *const u16, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS {
1157     #[cfg(windows)]
1158     {
1159         #[link(name = "windows")]
1160         extern "system" {
1161             fn I_RpcServerStartService(protseq: *const u16, endpoint: *const u16, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS;
1162         }
1163         ::std::mem::transmute(I_RpcServerStartService(::std::mem::transmute(protseq), ::std::mem::transmute(endpoint), ::std::mem::transmute(ifspec)))
1164     }
1165     #[cfg(not(windows))]
1166     unimplemented!("Unsupported target OS");
1167 }
1168 #[inline]
I_RpcServerSubscribeForDisconnectNotification(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void) -> RPC_STATUS1169 pub unsafe fn I_RpcServerSubscribeForDisconnectNotification(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void) -> RPC_STATUS {
1170     #[cfg(windows)]
1171     {
1172         #[link(name = "windows")]
1173         extern "system" {
1174             fn I_RpcServerSubscribeForDisconnectNotification(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void) -> RPC_STATUS;
1175         }
1176         ::std::mem::transmute(I_RpcServerSubscribeForDisconnectNotification(::std::mem::transmute(binding), ::std::mem::transmute(hevent)))
1177     }
1178     #[cfg(not(windows))]
1179     unimplemented!("Unsupported target OS");
1180 }
1181 #[inline]
I_RpcServerSubscribeForDisconnectNotification2(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void, subscriptionid: *mut ::windows::runtime::GUID) -> RPC_STATUS1182 pub unsafe fn I_RpcServerSubscribeForDisconnectNotification2(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void, subscriptionid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
1183     #[cfg(windows)]
1184     {
1185         #[link(name = "windows")]
1186         extern "system" {
1187             fn I_RpcServerSubscribeForDisconnectNotification2(binding: *const ::std::ffi::c_void, hevent: *const ::std::ffi::c_void, subscriptionid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
1188         }
1189         ::std::mem::transmute(I_RpcServerSubscribeForDisconnectNotification2(::std::mem::transmute(binding), ::std::mem::transmute(hevent), ::std::mem::transmute(subscriptionid)))
1190     }
1191     #[cfg(not(windows))]
1192     unimplemented!("Unsupported target OS");
1193 }
1194 #[inline]
I_RpcServerUnsubscribeForDisconnectNotification<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(binding: *const ::std::ffi::c_void, subscriptionid: Param1) -> RPC_STATUS1195 pub unsafe fn I_RpcServerUnsubscribeForDisconnectNotification<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::GUID>>(binding: *const ::std::ffi::c_void, subscriptionid: Param1) -> RPC_STATUS {
1196     #[cfg(windows)]
1197     {
1198         #[link(name = "windows")]
1199         extern "system" {
1200             fn I_RpcServerUnsubscribeForDisconnectNotification(binding: *const ::std::ffi::c_void, subscriptionid: ::windows::runtime::GUID) -> RPC_STATUS;
1201         }
1202         ::std::mem::transmute(I_RpcServerUnsubscribeForDisconnectNotification(::std::mem::transmute(binding), subscriptionid.into_param().abi()))
1203     }
1204     #[cfg(not(windows))]
1205     unimplemented!("Unsupported target OS");
1206 }
1207 #[inline]
I_RpcServerUseProtseq2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS1208 pub unsafe fn I_RpcServerUseProtseq2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS {
1209     #[cfg(windows)]
1210     {
1211         #[link(name = "windows")]
1212         extern "system" {
1213             fn I_RpcServerUseProtseq2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS;
1214         }
1215         ::std::mem::transmute(I_RpcServerUseProtseq2A(::std::mem::transmute(networkaddress), ::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
1216     }
1217     #[cfg(not(windows))]
1218     unimplemented!("Unsupported target OS");
1219 }
1220 #[inline]
I_RpcServerUseProtseq2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS1221 pub unsafe fn I_RpcServerUseProtseq2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS {
1222     #[cfg(windows)]
1223     {
1224         #[link(name = "windows")]
1225         extern "system" {
1226             fn I_RpcServerUseProtseq2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS;
1227         }
1228         ::std::mem::transmute(I_RpcServerUseProtseq2W(::std::mem::transmute(networkaddress), ::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
1229     }
1230     #[cfg(not(windows))]
1231     unimplemented!("Unsupported target OS");
1232 }
1233 #[inline]
I_RpcServerUseProtseqEp2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS1234 pub unsafe fn I_RpcServerUseProtseqEp2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS {
1235     #[cfg(windows)]
1236     {
1237         #[link(name = "windows")]
1238         extern "system" {
1239             fn I_RpcServerUseProtseqEp2A(networkaddress: *const u8, protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS;
1240         }
1241         ::std::mem::transmute(I_RpcServerUseProtseqEp2A(::std::mem::transmute(networkaddress), ::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
1242     }
1243     #[cfg(not(windows))]
1244     unimplemented!("Unsupported target OS");
1245 }
1246 #[inline]
I_RpcServerUseProtseqEp2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS1247 pub unsafe fn I_RpcServerUseProtseqEp2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS {
1248     #[cfg(windows)]
1249     {
1250         #[link(name = "windows")]
1251         extern "system" {
1252             fn I_RpcServerUseProtseqEp2W(networkaddress: *const u16, protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const ::std::ffi::c_void) -> RPC_STATUS;
1253         }
1254         ::std::mem::transmute(I_RpcServerUseProtseqEp2W(::std::mem::transmute(networkaddress), ::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
1255     }
1256     #[cfg(not(windows))]
1257     unimplemented!("Unsupported target OS");
1258 }
1259 #[inline]
I_RpcSessionStrictContextHandle()1260 pub unsafe fn I_RpcSessionStrictContextHandle() {
1261     #[cfg(windows)]
1262     {
1263         #[link(name = "windows")]
1264         extern "system" {
1265             fn I_RpcSessionStrictContextHandle();
1266         }
1267         ::std::mem::transmute(I_RpcSessionStrictContextHandle())
1268     }
1269     #[cfg(not(windows))]
1270     unimplemented!("Unsupported target OS");
1271 }
1272 #[inline]
I_RpcSsDontSerializeContext()1273 pub unsafe fn I_RpcSsDontSerializeContext() {
1274     #[cfg(windows)]
1275     {
1276         #[link(name = "windows")]
1277         extern "system" {
1278             fn I_RpcSsDontSerializeContext();
1279         }
1280         ::std::mem::transmute(I_RpcSsDontSerializeContext())
1281     }
1282     #[cfg(not(windows))]
1283     unimplemented!("Unsupported target OS");
1284 }
1285 #[inline]
I_RpcSystemHandleTypeSpecificWork(handle: *mut ::std::ffi::c_void, actualtype: u8, idltype: u8, marshaldirection: LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION) -> RPC_STATUS1286 pub unsafe fn I_RpcSystemHandleTypeSpecificWork(handle: *mut ::std::ffi::c_void, actualtype: u8, idltype: u8, marshaldirection: LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION) -> RPC_STATUS {
1287     #[cfg(windows)]
1288     {
1289         #[link(name = "windows")]
1290         extern "system" {
1291             fn I_RpcSystemHandleTypeSpecificWork(handle: *mut ::std::ffi::c_void, actualtype: u8, idltype: u8, marshaldirection: LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION) -> RPC_STATUS;
1292         }
1293         ::std::mem::transmute(I_RpcSystemHandleTypeSpecificWork(::std::mem::transmute(handle), ::std::mem::transmute(actualtype), ::std::mem::transmute(idltype), ::std::mem::transmute(marshaldirection)))
1294     }
1295     #[cfg(not(windows))]
1296     unimplemented!("Unsupported target OS");
1297 }
1298 #[inline]
I_RpcTurnOnEEInfoPropagation() -> RPC_STATUS1299 pub unsafe fn I_RpcTurnOnEEInfoPropagation() -> RPC_STATUS {
1300     #[cfg(windows)]
1301     {
1302         #[link(name = "windows")]
1303         extern "system" {
1304             fn I_RpcTurnOnEEInfoPropagation() -> RPC_STATUS;
1305         }
1306         ::std::mem::transmute(I_RpcTurnOnEEInfoPropagation())
1307     }
1308     #[cfg(not(windows))]
1309     unimplemented!("Unsupported target OS");
1310 }
1311 #[inline]
I_UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS1312 pub unsafe fn I_UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
1313     #[cfg(windows)]
1314     {
1315         #[link(name = "windows")]
1316         extern "system" {
1317             fn I_UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
1318         }
1319         ::std::mem::transmute(I_UuidCreate(::std::mem::transmute(uuid)))
1320     }
1321     #[cfg(not(windows))]
1322     unimplemented!("Unsupported target OS");
1323 }
1324 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1325 #[repr(transparent)]
1326 pub struct LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION(pub i32);
1327 pub const MarshalDirectionMarshal: LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION = LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION(0i32);
1328 pub const MarshalDirectionUnmarshal: LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION = LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION(1i32);
1329 impl ::std::convert::From<i32> for LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION {
from(value: i32) -> Self1330     fn from(value: i32) -> Self {
1331         Self(value)
1332     }
1333 }
1334 unsafe impl ::windows::runtime::Abi for LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION {
1335     type Abi = Self;
1336     type DefaultType = Self;
1337 }
1338 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1339 #[repr(C)]
1340 pub struct MALLOC_FREE_STRUCT {
1341     pub pfnAllocate: isize,
1342     pub pfnFree: isize,
1343 }
1344 impl MALLOC_FREE_STRUCT {}
1345 impl ::std::default::Default for MALLOC_FREE_STRUCT {
default() -> Self1346     fn default() -> Self {
1347         unsafe { ::std::mem::zeroed() }
1348     }
1349 }
1350 impl ::std::fmt::Debug for MALLOC_FREE_STRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1351     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1352         fmt.debug_struct("MALLOC_FREE_STRUCT").field("pfnAllocate", &self.pfnAllocate).field("pfnFree", &self.pfnFree).finish()
1353     }
1354 }
1355 impl ::std::cmp::PartialEq for MALLOC_FREE_STRUCT {
eq(&self, other: &Self) -> bool1356     fn eq(&self, other: &Self) -> bool {
1357         self.pfnAllocate == other.pfnAllocate && self.pfnFree == other.pfnFree
1358     }
1359 }
1360 impl ::std::cmp::Eq for MALLOC_FREE_STRUCT {}
1361 unsafe impl ::windows::runtime::Abi for MALLOC_FREE_STRUCT {
1362     type Abi = Self;
1363     type DefaultType = Self;
1364 }
1365 pub type MIDL_ES_ALLOC = unsafe extern "system" fn(state: *mut ::std::ffi::c_void, pbuffer: *mut *mut i8, psize: *mut u32);
1366 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1367 #[repr(transparent)]
1368 pub struct MIDL_ES_CODE(pub i32);
1369 pub const MES_ENCODE: MIDL_ES_CODE = MIDL_ES_CODE(0i32);
1370 pub const MES_DECODE: MIDL_ES_CODE = MIDL_ES_CODE(1i32);
1371 pub const MES_ENCODE_NDR64: MIDL_ES_CODE = MIDL_ES_CODE(2i32);
1372 impl ::std::convert::From<i32> for MIDL_ES_CODE {
from(value: i32) -> Self1373     fn from(value: i32) -> Self {
1374         Self(value)
1375     }
1376 }
1377 unsafe impl ::windows::runtime::Abi for MIDL_ES_CODE {
1378     type Abi = Self;
1379     type DefaultType = Self;
1380 }
1381 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1382 #[repr(transparent)]
1383 pub struct MIDL_ES_HANDLE_STYLE(pub i32);
1384 pub const MES_INCREMENTAL_HANDLE: MIDL_ES_HANDLE_STYLE = MIDL_ES_HANDLE_STYLE(0i32);
1385 pub const MES_FIXED_BUFFER_HANDLE: MIDL_ES_HANDLE_STYLE = MIDL_ES_HANDLE_STYLE(1i32);
1386 pub const MES_DYNAMIC_BUFFER_HANDLE: MIDL_ES_HANDLE_STYLE = MIDL_ES_HANDLE_STYLE(2i32);
1387 impl ::std::convert::From<i32> for MIDL_ES_HANDLE_STYLE {
from(value: i32) -> Self1388     fn from(value: i32) -> Self {
1389         Self(value)
1390     }
1391 }
1392 unsafe impl ::windows::runtime::Abi for MIDL_ES_HANDLE_STYLE {
1393     type Abi = Self;
1394     type DefaultType = Self;
1395 }
1396 pub type MIDL_ES_READ = unsafe extern "system" fn(state: *mut ::std::ffi::c_void, pbuffer: *mut *mut i8, psize: *mut u32);
1397 #[cfg(feature = "Win32_Foundation")]
1398 pub type MIDL_ES_WRITE = unsafe extern "system" fn(state: *mut ::std::ffi::c_void, buffer: super::super::Foundation::PSTR, size: u32);
1399 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1400 #[repr(C)]
1401 pub struct MIDL_FORMAT_STRING {
1402     pub Pad: i16,
1403     pub Format: [u8; 1],
1404 }
1405 impl MIDL_FORMAT_STRING {}
1406 impl ::std::default::Default for MIDL_FORMAT_STRING {
default() -> Self1407     fn default() -> Self {
1408         unsafe { ::std::mem::zeroed() }
1409     }
1410 }
1411 impl ::std::fmt::Debug for MIDL_FORMAT_STRING {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1412     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1413         fmt.debug_struct("MIDL_FORMAT_STRING").field("Pad", &self.Pad).field("Format", &self.Format).finish()
1414     }
1415 }
1416 impl ::std::cmp::PartialEq for MIDL_FORMAT_STRING {
eq(&self, other: &Self) -> bool1417     fn eq(&self, other: &Self) -> bool {
1418         self.Pad == other.Pad && self.Format == other.Format
1419     }
1420 }
1421 impl ::std::cmp::Eq for MIDL_FORMAT_STRING {}
1422 unsafe impl ::windows::runtime::Abi for MIDL_FORMAT_STRING {
1423     type Abi = Self;
1424     type DefaultType = Self;
1425 }
1426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1427 #[repr(C)]
1428 pub struct MIDL_INTERCEPTION_INFO {
1429     pub Version: u32,
1430     pub ProcString: *mut u8,
1431     pub ProcFormatOffsetTable: *mut u16,
1432     pub ProcCount: u32,
1433     pub TypeString: *mut u8,
1434 }
1435 impl MIDL_INTERCEPTION_INFO {}
1436 impl ::std::default::Default for MIDL_INTERCEPTION_INFO {
default() -> Self1437     fn default() -> Self {
1438         unsafe { ::std::mem::zeroed() }
1439     }
1440 }
1441 impl ::std::fmt::Debug for MIDL_INTERCEPTION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1442     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1443         fmt.debug_struct("MIDL_INTERCEPTION_INFO").field("Version", &self.Version).field("ProcString", &self.ProcString).field("ProcFormatOffsetTable", &self.ProcFormatOffsetTable).field("ProcCount", &self.ProcCount).field("TypeString", &self.TypeString).finish()
1444     }
1445 }
1446 impl ::std::cmp::PartialEq for MIDL_INTERCEPTION_INFO {
eq(&self, other: &Self) -> bool1447     fn eq(&self, other: &Self) -> bool {
1448         self.Version == other.Version && self.ProcString == other.ProcString && self.ProcFormatOffsetTable == other.ProcFormatOffsetTable && self.ProcCount == other.ProcCount && self.TypeString == other.TypeString
1449     }
1450 }
1451 impl ::std::cmp::Eq for MIDL_INTERCEPTION_INFO {}
1452 unsafe impl ::windows::runtime::Abi for MIDL_INTERCEPTION_INFO {
1453     type Abi = Self;
1454     type DefaultType = Self;
1455 }
1456 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1457 #[repr(C)]
1458 pub struct MIDL_INTERFACE_METHOD_PROPERTIES {
1459     pub MethodCount: u16,
1460     pub MethodProperties: *mut *mut MIDL_METHOD_PROPERTY_MAP,
1461 }
1462 impl MIDL_INTERFACE_METHOD_PROPERTIES {}
1463 impl ::std::default::Default for MIDL_INTERFACE_METHOD_PROPERTIES {
default() -> Self1464     fn default() -> Self {
1465         unsafe { ::std::mem::zeroed() }
1466     }
1467 }
1468 impl ::std::fmt::Debug for MIDL_INTERFACE_METHOD_PROPERTIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1469     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1470         fmt.debug_struct("MIDL_INTERFACE_METHOD_PROPERTIES").field("MethodCount", &self.MethodCount).field("MethodProperties", &self.MethodProperties).finish()
1471     }
1472 }
1473 impl ::std::cmp::PartialEq for MIDL_INTERFACE_METHOD_PROPERTIES {
eq(&self, other: &Self) -> bool1474     fn eq(&self, other: &Self) -> bool {
1475         self.MethodCount == other.MethodCount && self.MethodProperties == other.MethodProperties
1476     }
1477 }
1478 impl ::std::cmp::Eq for MIDL_INTERFACE_METHOD_PROPERTIES {}
1479 unsafe impl ::windows::runtime::Abi for MIDL_INTERFACE_METHOD_PROPERTIES {
1480     type Abi = Self;
1481     type DefaultType = Self;
1482 }
1483 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1484 #[repr(C)]
1485 pub struct MIDL_METHOD_PROPERTY {
1486     pub Id: u32,
1487     pub Value: usize,
1488 }
1489 impl MIDL_METHOD_PROPERTY {}
1490 impl ::std::default::Default for MIDL_METHOD_PROPERTY {
default() -> Self1491     fn default() -> Self {
1492         unsafe { ::std::mem::zeroed() }
1493     }
1494 }
1495 impl ::std::fmt::Debug for MIDL_METHOD_PROPERTY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1496     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1497         fmt.debug_struct("MIDL_METHOD_PROPERTY").field("Id", &self.Id).field("Value", &self.Value).finish()
1498     }
1499 }
1500 impl ::std::cmp::PartialEq for MIDL_METHOD_PROPERTY {
eq(&self, other: &Self) -> bool1501     fn eq(&self, other: &Self) -> bool {
1502         self.Id == other.Id && self.Value == other.Value
1503     }
1504 }
1505 impl ::std::cmp::Eq for MIDL_METHOD_PROPERTY {}
1506 unsafe impl ::windows::runtime::Abi for MIDL_METHOD_PROPERTY {
1507     type Abi = Self;
1508     type DefaultType = Self;
1509 }
1510 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1511 #[repr(C)]
1512 pub struct MIDL_METHOD_PROPERTY_MAP {
1513     pub Count: u32,
1514     pub Properties: *mut MIDL_METHOD_PROPERTY,
1515 }
1516 impl MIDL_METHOD_PROPERTY_MAP {}
1517 impl ::std::default::Default for MIDL_METHOD_PROPERTY_MAP {
default() -> Self1518     fn default() -> Self {
1519         unsafe { ::std::mem::zeroed() }
1520     }
1521 }
1522 impl ::std::fmt::Debug for MIDL_METHOD_PROPERTY_MAP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1523     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1524         fmt.debug_struct("MIDL_METHOD_PROPERTY_MAP").field("Count", &self.Count).field("Properties", &self.Properties).finish()
1525     }
1526 }
1527 impl ::std::cmp::PartialEq for MIDL_METHOD_PROPERTY_MAP {
eq(&self, other: &Self) -> bool1528     fn eq(&self, other: &Self) -> bool {
1529         self.Count == other.Count && self.Properties == other.Properties
1530     }
1531 }
1532 impl ::std::cmp::Eq for MIDL_METHOD_PROPERTY_MAP {}
1533 unsafe impl ::windows::runtime::Abi for MIDL_METHOD_PROPERTY_MAP {
1534     type Abi = Self;
1535     type DefaultType = Self;
1536 }
1537 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1538 #[repr(C)]
1539 #[cfg(feature = "Win32_System_Com")]
1540 pub struct MIDL_SERVER_INFO {
1541     pub pStubDesc: *mut MIDL_STUB_DESC,
1542     pub DispatchTable: *mut ::std::option::Option<SERVER_ROUTINE>,
1543     pub ProcString: *mut u8,
1544     pub FmtStringOffset: *mut u16,
1545     pub ThunkTable: *mut ::std::option::Option<STUB_THUNK>,
1546     pub pTransferSyntax: *mut RPC_SYNTAX_IDENTIFIER,
1547     pub nCount: usize,
1548     pub pSyntaxInfo: *mut MIDL_SYNTAX_INFO,
1549 }
1550 #[cfg(feature = "Win32_System_Com")]
1551 impl MIDL_SERVER_INFO {}
1552 #[cfg(feature = "Win32_System_Com")]
1553 impl ::std::default::Default for MIDL_SERVER_INFO {
default() -> Self1554     fn default() -> Self {
1555         unsafe { ::std::mem::zeroed() }
1556     }
1557 }
1558 #[cfg(feature = "Win32_System_Com")]
1559 impl ::std::fmt::Debug for MIDL_SERVER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1560     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1561         fmt.debug_struct("MIDL_SERVER_INFO").field("pStubDesc", &self.pStubDesc).field("ProcString", &self.ProcString).field("FmtStringOffset", &self.FmtStringOffset).field("pTransferSyntax", &self.pTransferSyntax).field("nCount", &self.nCount).field("pSyntaxInfo", &self.pSyntaxInfo).finish()
1562     }
1563 }
1564 #[cfg(feature = "Win32_System_Com")]
1565 impl ::std::cmp::PartialEq for MIDL_SERVER_INFO {
eq(&self, other: &Self) -> bool1566     fn eq(&self, other: &Self) -> bool {
1567         self.pStubDesc == other.pStubDesc && self.DispatchTable == other.DispatchTable && self.ProcString == other.ProcString && self.FmtStringOffset == other.FmtStringOffset && self.ThunkTable == other.ThunkTable && self.pTransferSyntax == other.pTransferSyntax && self.nCount == other.nCount && self.pSyntaxInfo == other.pSyntaxInfo
1568     }
1569 }
1570 #[cfg(feature = "Win32_System_Com")]
1571 impl ::std::cmp::Eq for MIDL_SERVER_INFO {}
1572 #[cfg(feature = "Win32_System_Com")]
1573 unsafe impl ::windows::runtime::Abi for MIDL_SERVER_INFO {
1574     type Abi = Self;
1575     type DefaultType = Self;
1576 }
1577 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1578 #[repr(C)]
1579 #[cfg(feature = "Win32_System_Com")]
1580 pub struct MIDL_STUBLESS_PROXY_INFO {
1581     pub pStubDesc: *mut MIDL_STUB_DESC,
1582     pub ProcFormatString: *mut u8,
1583     pub FormatStringOffset: *mut u16,
1584     pub pTransferSyntax: *mut RPC_SYNTAX_IDENTIFIER,
1585     pub nCount: usize,
1586     pub pSyntaxInfo: *mut MIDL_SYNTAX_INFO,
1587 }
1588 #[cfg(feature = "Win32_System_Com")]
1589 impl MIDL_STUBLESS_PROXY_INFO {}
1590 #[cfg(feature = "Win32_System_Com")]
1591 impl ::std::default::Default for MIDL_STUBLESS_PROXY_INFO {
default() -> Self1592     fn default() -> Self {
1593         unsafe { ::std::mem::zeroed() }
1594     }
1595 }
1596 #[cfg(feature = "Win32_System_Com")]
1597 impl ::std::fmt::Debug for MIDL_STUBLESS_PROXY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1598     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1599         fmt.debug_struct("MIDL_STUBLESS_PROXY_INFO")
1600             .field("pStubDesc", &self.pStubDesc)
1601             .field("ProcFormatString", &self.ProcFormatString)
1602             .field("FormatStringOffset", &self.FormatStringOffset)
1603             .field("pTransferSyntax", &self.pTransferSyntax)
1604             .field("nCount", &self.nCount)
1605             .field("pSyntaxInfo", &self.pSyntaxInfo)
1606             .finish()
1607     }
1608 }
1609 #[cfg(feature = "Win32_System_Com")]
1610 impl ::std::cmp::PartialEq for MIDL_STUBLESS_PROXY_INFO {
eq(&self, other: &Self) -> bool1611     fn eq(&self, other: &Self) -> bool {
1612         self.pStubDesc == other.pStubDesc && self.ProcFormatString == other.ProcFormatString && self.FormatStringOffset == other.FormatStringOffset && self.pTransferSyntax == other.pTransferSyntax && self.nCount == other.nCount && self.pSyntaxInfo == other.pSyntaxInfo
1613     }
1614 }
1615 #[cfg(feature = "Win32_System_Com")]
1616 impl ::std::cmp::Eq for MIDL_STUBLESS_PROXY_INFO {}
1617 #[cfg(feature = "Win32_System_Com")]
1618 unsafe impl ::windows::runtime::Abi for MIDL_STUBLESS_PROXY_INFO {
1619     type Abi = Self;
1620     type DefaultType = Self;
1621 }
1622 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1623 #[repr(C)]
1624 #[cfg(feature = "Win32_System_Com")]
1625 pub struct MIDL_STUB_DESC {
1626     pub RpcInterfaceInformation: *mut ::std::ffi::c_void,
1627     pub pfnAllocate: isize,
1628     pub pfnFree: isize,
1629     pub IMPLICIT_HANDLE_INFO: MIDL_STUB_DESC_0,
1630     pub apfnNdrRundownRoutines: *mut ::std::option::Option<NDR_RUNDOWN>,
1631     pub aGenericBindingRoutinePairs: *mut GENERIC_BINDING_ROUTINE_PAIR,
1632     pub apfnExprEval: *mut ::std::option::Option<EXPR_EVAL>,
1633     pub aXmitQuintuple: *mut XMIT_ROUTINE_QUINTUPLE,
1634     pub pFormatTypes: *mut u8,
1635     pub fCheckBounds: i32,
1636     pub Version: u32,
1637     pub pMallocFreeStruct: *mut MALLOC_FREE_STRUCT,
1638     pub MIDLVersion: i32,
1639     pub CommFaultOffsets: *mut COMM_FAULT_OFFSETS,
1640     pub aUserMarshalQuadruple: *mut USER_MARSHAL_ROUTINE_QUADRUPLE,
1641     pub NotifyRoutineTable: *mut ::std::option::Option<NDR_NOTIFY_ROUTINE>,
1642     pub mFlags: usize,
1643     pub CsRoutineTables: *mut NDR_CS_ROUTINES,
1644     pub ProxyServerInfo: *mut ::std::ffi::c_void,
1645     pub pExprInfo: *mut NDR_EXPR_DESC,
1646 }
1647 #[cfg(feature = "Win32_System_Com")]
1648 impl MIDL_STUB_DESC {}
1649 #[cfg(feature = "Win32_System_Com")]
1650 impl ::std::default::Default for MIDL_STUB_DESC {
default() -> Self1651     fn default() -> Self {
1652         unsafe { ::std::mem::zeroed() }
1653     }
1654 }
1655 #[cfg(feature = "Win32_System_Com")]
1656 impl ::std::cmp::PartialEq for MIDL_STUB_DESC {
eq(&self, _other: &Self) -> bool1657     fn eq(&self, _other: &Self) -> bool {
1658         unimplemented!()
1659     }
1660 }
1661 #[cfg(feature = "Win32_System_Com")]
1662 impl ::std::cmp::Eq for MIDL_STUB_DESC {}
1663 #[cfg(feature = "Win32_System_Com")]
1664 unsafe impl ::windows::runtime::Abi for MIDL_STUB_DESC {
1665     type Abi = Self;
1666     type DefaultType = Self;
1667 }
1668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1669 #[repr(C)]
1670 pub union MIDL_STUB_DESC_0 {
1671     pub pAutoHandle: *mut *mut ::std::ffi::c_void,
1672     pub pPrimitiveHandle: *mut *mut ::std::ffi::c_void,
1673     pub pGenericBindingInfo: *mut ::std::mem::ManuallyDrop<GENERIC_BINDING_INFO>,
1674 }
1675 impl MIDL_STUB_DESC_0 {}
1676 impl ::std::default::Default for MIDL_STUB_DESC_0 {
default() -> Self1677     fn default() -> Self {
1678         unsafe { ::std::mem::zeroed() }
1679     }
1680 }
1681 impl ::std::cmp::PartialEq for MIDL_STUB_DESC_0 {
eq(&self, _other: &Self) -> bool1682     fn eq(&self, _other: &Self) -> bool {
1683         unimplemented!()
1684     }
1685 }
1686 impl ::std::cmp::Eq for MIDL_STUB_DESC_0 {}
1687 unsafe impl ::windows::runtime::Abi for MIDL_STUB_DESC_0 {
1688     type Abi = Self;
1689     type DefaultType = Self;
1690 }
1691 #[derive(:: std :: clone :: Clone)]
1692 #[repr(C)]
1693 #[cfg(feature = "Win32_System_Com")]
1694 pub struct MIDL_STUB_MESSAGE {
1695     pub RpcMsg: *mut RPC_MESSAGE,
1696     pub Buffer: *mut u8,
1697     pub BufferStart: *mut u8,
1698     pub BufferEnd: *mut u8,
1699     pub BufferMark: *mut u8,
1700     pub BufferLength: u32,
1701     pub MemorySize: u32,
1702     pub Memory: *mut u8,
1703     pub IsClient: u8,
1704     pub Pad: u8,
1705     pub uFlags2: u16,
1706     pub ReuseBuffer: i32,
1707     pub pAllocAllNodesContext: *mut NDR_ALLOC_ALL_NODES_CONTEXT,
1708     pub pPointerQueueState: *mut NDR_POINTER_QUEUE_STATE,
1709     pub IgnoreEmbeddedPointers: i32,
1710     pub PointerBufferMark: *mut u8,
1711     pub CorrDespIncrement: u8,
1712     pub uFlags: u8,
1713     pub UniquePtrCount: u16,
1714     pub MaxCount: usize,
1715     pub Offset: u32,
1716     pub ActualCount: u32,
1717     pub pfnAllocate: isize,
1718     pub pfnFree: isize,
1719     pub StackTop: *mut u8,
1720     pub pPresentedType: *mut u8,
1721     pub pTransmitType: *mut u8,
1722     pub SavedHandle: *mut ::std::ffi::c_void,
1723     pub StubDesc: *mut MIDL_STUB_DESC,
1724     pub FullPtrXlatTables: *mut FULL_PTR_XLAT_TABLES,
1725     pub FullPtrRefId: u32,
1726     pub PointerLength: u32,
1727     pub _bitfield: i32,
1728     pub dwDestContext: u32,
1729     pub pvDestContext: *mut ::std::ffi::c_void,
1730     pub SavedContextHandles: *mut *mut NDR_SCONTEXT_1,
1731     pub ParamNumber: i32,
1732     pub pRpcChannelBuffer: ::std::option::Option<super::Com::IRpcChannelBuffer>,
1733     pub pArrayInfo: *mut ARRAY_INFO,
1734     pub SizePtrCountArray: *mut u32,
1735     pub SizePtrOffsetArray: *mut u32,
1736     pub SizePtrLengthArray: *mut u32,
1737     pub pArgQueue: *mut ::std::ffi::c_void,
1738     pub dwStubPhase: u32,
1739     pub LowStackMark: *mut ::std::ffi::c_void,
1740     pub pAsyncMsg: *mut _NDR_ASYNC_MESSAGE,
1741     pub pCorrInfo: *mut _NDR_CORRELATION_INFO,
1742     pub pCorrMemory: *mut u8,
1743     pub pMemoryList: *mut ::std::ffi::c_void,
1744     pub pCSInfo: isize,
1745     pub ConformanceMark: *mut u8,
1746     pub VarianceMark: *mut u8,
1747     pub Unused: isize,
1748     pub pContext: *mut _NDR_PROC_CONTEXT,
1749     pub ContextHandleHash: *mut ::std::ffi::c_void,
1750     pub pUserMarshalList: *mut ::std::ffi::c_void,
1751     pub Reserved51_3: isize,
1752     pub Reserved51_4: isize,
1753     pub Reserved51_5: isize,
1754 }
1755 #[cfg(feature = "Win32_System_Com")]
1756 impl MIDL_STUB_MESSAGE {}
1757 #[cfg(feature = "Win32_System_Com")]
1758 impl ::std::default::Default for MIDL_STUB_MESSAGE {
default() -> Self1759     fn default() -> Self {
1760         unsafe { ::std::mem::zeroed() }
1761     }
1762 }
1763 #[cfg(feature = "Win32_System_Com")]
1764 impl ::std::fmt::Debug for MIDL_STUB_MESSAGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1765     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1766         fmt.debug_struct("MIDL_STUB_MESSAGE")
1767             .field("RpcMsg", &self.RpcMsg)
1768             .field("Buffer", &self.Buffer)
1769             .field("BufferStart", &self.BufferStart)
1770             .field("BufferEnd", &self.BufferEnd)
1771             .field("BufferMark", &self.BufferMark)
1772             .field("BufferLength", &self.BufferLength)
1773             .field("MemorySize", &self.MemorySize)
1774             .field("Memory", &self.Memory)
1775             .field("IsClient", &self.IsClient)
1776             .field("Pad", &self.Pad)
1777             .field("uFlags2", &self.uFlags2)
1778             .field("ReuseBuffer", &self.ReuseBuffer)
1779             .field("pAllocAllNodesContext", &self.pAllocAllNodesContext)
1780             .field("pPointerQueueState", &self.pPointerQueueState)
1781             .field("IgnoreEmbeddedPointers", &self.IgnoreEmbeddedPointers)
1782             .field("PointerBufferMark", &self.PointerBufferMark)
1783             .field("CorrDespIncrement", &self.CorrDespIncrement)
1784             .field("uFlags", &self.uFlags)
1785             .field("UniquePtrCount", &self.UniquePtrCount)
1786             .field("MaxCount", &self.MaxCount)
1787             .field("Offset", &self.Offset)
1788             .field("ActualCount", &self.ActualCount)
1789             .field("pfnAllocate", &self.pfnAllocate)
1790             .field("pfnFree", &self.pfnFree)
1791             .field("StackTop", &self.StackTop)
1792             .field("pPresentedType", &self.pPresentedType)
1793             .field("pTransmitType", &self.pTransmitType)
1794             .field("SavedHandle", &self.SavedHandle)
1795             .field("StubDesc", &self.StubDesc)
1796             .field("FullPtrXlatTables", &self.FullPtrXlatTables)
1797             .field("FullPtrRefId", &self.FullPtrRefId)
1798             .field("PointerLength", &self.PointerLength)
1799             .field("_bitfield", &self._bitfield)
1800             .field("dwDestContext", &self.dwDestContext)
1801             .field("pvDestContext", &self.pvDestContext)
1802             .field("SavedContextHandles", &self.SavedContextHandles)
1803             .field("ParamNumber", &self.ParamNumber)
1804             .field("pRpcChannelBuffer", &self.pRpcChannelBuffer)
1805             .field("pArrayInfo", &self.pArrayInfo)
1806             .field("SizePtrCountArray", &self.SizePtrCountArray)
1807             .field("SizePtrOffsetArray", &self.SizePtrOffsetArray)
1808             .field("SizePtrLengthArray", &self.SizePtrLengthArray)
1809             .field("pArgQueue", &self.pArgQueue)
1810             .field("dwStubPhase", &self.dwStubPhase)
1811             .field("LowStackMark", &self.LowStackMark)
1812             .field("pAsyncMsg", &self.pAsyncMsg)
1813             .field("pCorrInfo", &self.pCorrInfo)
1814             .field("pCorrMemory", &self.pCorrMemory)
1815             .field("pMemoryList", &self.pMemoryList)
1816             .field("pCSInfo", &self.pCSInfo)
1817             .field("ConformanceMark", &self.ConformanceMark)
1818             .field("VarianceMark", &self.VarianceMark)
1819             .field("Unused", &self.Unused)
1820             .field("pContext", &self.pContext)
1821             .field("ContextHandleHash", &self.ContextHandleHash)
1822             .field("pUserMarshalList", &self.pUserMarshalList)
1823             .field("Reserved51_3", &self.Reserved51_3)
1824             .field("Reserved51_4", &self.Reserved51_4)
1825             .field("Reserved51_5", &self.Reserved51_5)
1826             .finish()
1827     }
1828 }
1829 #[cfg(feature = "Win32_System_Com")]
1830 impl ::std::cmp::PartialEq for MIDL_STUB_MESSAGE {
eq(&self, other: &Self) -> bool1831     fn eq(&self, other: &Self) -> bool {
1832         self.RpcMsg == other.RpcMsg
1833             && self.Buffer == other.Buffer
1834             && self.BufferStart == other.BufferStart
1835             && self.BufferEnd == other.BufferEnd
1836             && self.BufferMark == other.BufferMark
1837             && self.BufferLength == other.BufferLength
1838             && self.MemorySize == other.MemorySize
1839             && self.Memory == other.Memory
1840             && self.IsClient == other.IsClient
1841             && self.Pad == other.Pad
1842             && self.uFlags2 == other.uFlags2
1843             && self.ReuseBuffer == other.ReuseBuffer
1844             && self.pAllocAllNodesContext == other.pAllocAllNodesContext
1845             && self.pPointerQueueState == other.pPointerQueueState
1846             && self.IgnoreEmbeddedPointers == other.IgnoreEmbeddedPointers
1847             && self.PointerBufferMark == other.PointerBufferMark
1848             && self.CorrDespIncrement == other.CorrDespIncrement
1849             && self.uFlags == other.uFlags
1850             && self.UniquePtrCount == other.UniquePtrCount
1851             && self.MaxCount == other.MaxCount
1852             && self.Offset == other.Offset
1853             && self.ActualCount == other.ActualCount
1854             && self.pfnAllocate == other.pfnAllocate
1855             && self.pfnFree == other.pfnFree
1856             && self.StackTop == other.StackTop
1857             && self.pPresentedType == other.pPresentedType
1858             && self.pTransmitType == other.pTransmitType
1859             && self.SavedHandle == other.SavedHandle
1860             && self.StubDesc == other.StubDesc
1861             && self.FullPtrXlatTables == other.FullPtrXlatTables
1862             && self.FullPtrRefId == other.FullPtrRefId
1863             && self.PointerLength == other.PointerLength
1864             && self._bitfield == other._bitfield
1865             && self.dwDestContext == other.dwDestContext
1866             && self.pvDestContext == other.pvDestContext
1867             && self.SavedContextHandles == other.SavedContextHandles
1868             && self.ParamNumber == other.ParamNumber
1869             && self.pRpcChannelBuffer == other.pRpcChannelBuffer
1870             && self.pArrayInfo == other.pArrayInfo
1871             && self.SizePtrCountArray == other.SizePtrCountArray
1872             && self.SizePtrOffsetArray == other.SizePtrOffsetArray
1873             && self.SizePtrLengthArray == other.SizePtrLengthArray
1874             && self.pArgQueue == other.pArgQueue
1875             && self.dwStubPhase == other.dwStubPhase
1876             && self.LowStackMark == other.LowStackMark
1877             && self.pAsyncMsg == other.pAsyncMsg
1878             && self.pCorrInfo == other.pCorrInfo
1879             && self.pCorrMemory == other.pCorrMemory
1880             && self.pMemoryList == other.pMemoryList
1881             && self.pCSInfo == other.pCSInfo
1882             && self.ConformanceMark == other.ConformanceMark
1883             && self.VarianceMark == other.VarianceMark
1884             && self.Unused == other.Unused
1885             && self.pContext == other.pContext
1886             && self.ContextHandleHash == other.ContextHandleHash
1887             && self.pUserMarshalList == other.pUserMarshalList
1888             && self.Reserved51_3 == other.Reserved51_3
1889             && self.Reserved51_4 == other.Reserved51_4
1890             && self.Reserved51_5 == other.Reserved51_5
1891     }
1892 }
1893 #[cfg(feature = "Win32_System_Com")]
1894 impl ::std::cmp::Eq for MIDL_STUB_MESSAGE {}
1895 #[cfg(feature = "Win32_System_Com")]
1896 unsafe impl ::windows::runtime::Abi for MIDL_STUB_MESSAGE {
1897     type Abi = ::std::mem::ManuallyDrop<Self>;
1898     type DefaultType = Self;
1899 }
1900 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1901 #[repr(C)]
1902 pub struct MIDL_SYNTAX_INFO {
1903     pub TransferSyntax: RPC_SYNTAX_IDENTIFIER,
1904     pub DispatchTable: *mut RPC_DISPATCH_TABLE,
1905     pub ProcString: *mut u8,
1906     pub FmtStringOffset: *mut u16,
1907     pub TypeString: *mut u8,
1908     pub aUserMarshalQuadruple: *mut ::std::ffi::c_void,
1909     pub pMethodProperties: *mut MIDL_INTERFACE_METHOD_PROPERTIES,
1910     pub pReserved2: usize,
1911 }
1912 impl MIDL_SYNTAX_INFO {}
1913 impl ::std::default::Default for MIDL_SYNTAX_INFO {
default() -> Self1914     fn default() -> Self {
1915         unsafe { ::std::mem::zeroed() }
1916     }
1917 }
1918 impl ::std::fmt::Debug for MIDL_SYNTAX_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1919     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1920         fmt.debug_struct("MIDL_SYNTAX_INFO")
1921             .field("TransferSyntax", &self.TransferSyntax)
1922             .field("DispatchTable", &self.DispatchTable)
1923             .field("ProcString", &self.ProcString)
1924             .field("FmtStringOffset", &self.FmtStringOffset)
1925             .field("TypeString", &self.TypeString)
1926             .field("aUserMarshalQuadruple", &self.aUserMarshalQuadruple)
1927             .field("pMethodProperties", &self.pMethodProperties)
1928             .field("pReserved2", &self.pReserved2)
1929             .finish()
1930     }
1931 }
1932 impl ::std::cmp::PartialEq for MIDL_SYNTAX_INFO {
eq(&self, other: &Self) -> bool1933     fn eq(&self, other: &Self) -> bool {
1934         self.TransferSyntax == other.TransferSyntax && self.DispatchTable == other.DispatchTable && self.ProcString == other.ProcString && self.FmtStringOffset == other.FmtStringOffset && self.TypeString == other.TypeString && self.aUserMarshalQuadruple == other.aUserMarshalQuadruple && self.pMethodProperties == other.pMethodProperties && self.pReserved2 == other.pReserved2
1935     }
1936 }
1937 impl ::std::cmp::Eq for MIDL_SYNTAX_INFO {}
1938 unsafe impl ::windows::runtime::Abi for MIDL_SYNTAX_INFO {
1939     type Abi = Self;
1940     type DefaultType = Self;
1941 }
1942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1943 #[repr(C)]
1944 pub struct MIDL_TYPE_PICKLING_INFO {
1945     pub Version: u32,
1946     pub Flags: u32,
1947     pub Reserved: [usize; 3],
1948 }
1949 impl MIDL_TYPE_PICKLING_INFO {}
1950 impl ::std::default::Default for MIDL_TYPE_PICKLING_INFO {
default() -> Self1951     fn default() -> Self {
1952         unsafe { ::std::mem::zeroed() }
1953     }
1954 }
1955 impl ::std::fmt::Debug for MIDL_TYPE_PICKLING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1956     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1957         fmt.debug_struct("MIDL_TYPE_PICKLING_INFO").field("Version", &self.Version).field("Flags", &self.Flags).field("Reserved", &self.Reserved).finish()
1958     }
1959 }
1960 impl ::std::cmp::PartialEq for MIDL_TYPE_PICKLING_INFO {
eq(&self, other: &Self) -> bool1961     fn eq(&self, other: &Self) -> bool {
1962         self.Version == other.Version && self.Flags == other.Flags && self.Reserved == other.Reserved
1963     }
1964 }
1965 impl ::std::cmp::Eq for MIDL_TYPE_PICKLING_INFO {}
1966 unsafe impl ::windows::runtime::Abi for MIDL_TYPE_PICKLING_INFO {
1967     type Abi = Self;
1968     type DefaultType = Self;
1969 }
1970 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1971 #[repr(C)]
1972 #[cfg(feature = "Win32_System_Com")]
1973 pub struct MIDL_WINRT_TYPE_SERIALIZATION_INFO {
1974     pub Version: u32,
1975     pub TypeFormatString: *mut u8,
1976     pub FormatStringSize: u16,
1977     pub TypeOffset: u16,
1978     pub StubDesc: *mut MIDL_STUB_DESC,
1979 }
1980 #[cfg(feature = "Win32_System_Com")]
1981 impl MIDL_WINRT_TYPE_SERIALIZATION_INFO {}
1982 #[cfg(feature = "Win32_System_Com")]
1983 impl ::std::default::Default for MIDL_WINRT_TYPE_SERIALIZATION_INFO {
default() -> Self1984     fn default() -> Self {
1985         unsafe { ::std::mem::zeroed() }
1986     }
1987 }
1988 #[cfg(feature = "Win32_System_Com")]
1989 impl ::std::fmt::Debug for MIDL_WINRT_TYPE_SERIALIZATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1990     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1991         fmt.debug_struct("MIDL_WINRT_TYPE_SERIALIZATION_INFO").field("Version", &self.Version).field("TypeFormatString", &self.TypeFormatString).field("FormatStringSize", &self.FormatStringSize).field("TypeOffset", &self.TypeOffset).field("StubDesc", &self.StubDesc).finish()
1992     }
1993 }
1994 #[cfg(feature = "Win32_System_Com")]
1995 impl ::std::cmp::PartialEq for MIDL_WINRT_TYPE_SERIALIZATION_INFO {
eq(&self, other: &Self) -> bool1996     fn eq(&self, other: &Self) -> bool {
1997         self.Version == other.Version && self.TypeFormatString == other.TypeFormatString && self.FormatStringSize == other.FormatStringSize && self.TypeOffset == other.TypeOffset && self.StubDesc == other.StubDesc
1998     }
1999 }
2000 #[cfg(feature = "Win32_System_Com")]
2001 impl ::std::cmp::Eq for MIDL_WINRT_TYPE_SERIALIZATION_INFO {}
2002 #[cfg(feature = "Win32_System_Com")]
2003 unsafe impl ::windows::runtime::Abi for MIDL_WINRT_TYPE_SERIALIZATION_INFO {
2004     type Abi = Self;
2005     type DefaultType = Self;
2006 }
2007 pub const MIDL_WINRT_TYPE_SERIALIZATION_INFO_CURRENT_VERSION: i32 = 1i32;
2008 pub const MaxNumberOfEEInfoParams: u32 = 4u32;
2009 #[inline]
MesBufferHandleReset(handle: *const ::std::ffi::c_void, handlestyle: u32, operation: MIDL_ES_CODE, pbuffer: *const *const i8, buffersize: u32, pencodedsize: *mut u32) -> RPC_STATUS2010 pub unsafe fn MesBufferHandleReset(handle: *const ::std::ffi::c_void, handlestyle: u32, operation: MIDL_ES_CODE, pbuffer: *const *const i8, buffersize: u32, pencodedsize: *mut u32) -> RPC_STATUS {
2011     #[cfg(windows)]
2012     {
2013         #[link(name = "windows")]
2014         extern "system" {
2015             fn MesBufferHandleReset(handle: *const ::std::ffi::c_void, handlestyle: u32, operation: MIDL_ES_CODE, pbuffer: *const *const i8, buffersize: u32, pencodedsize: *mut u32) -> RPC_STATUS;
2016         }
2017         ::std::mem::transmute(MesBufferHandleReset(::std::mem::transmute(handle), ::std::mem::transmute(handlestyle), ::std::mem::transmute(operation), ::std::mem::transmute(pbuffer), ::std::mem::transmute(buffersize), ::std::mem::transmute(pencodedsize)))
2018     }
2019     #[cfg(not(windows))]
2020     unimplemented!("Unsupported target OS");
2021 }
2022 #[cfg(feature = "Win32_Foundation")]
2023 #[inline]
MesDecodeBufferHandleCreate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(buffer: Param0, buffersize: u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS2024 pub unsafe fn MesDecodeBufferHandleCreate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(buffer: Param0, buffersize: u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
2025     #[cfg(windows)]
2026     {
2027         #[link(name = "windows")]
2028         extern "system" {
2029             fn MesDecodeBufferHandleCreate(buffer: super::super::Foundation::PSTR, buffersize: u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
2030         }
2031         ::std::mem::transmute(MesDecodeBufferHandleCreate(buffer.into_param().abi(), ::std::mem::transmute(buffersize), ::std::mem::transmute(phandle)))
2032     }
2033     #[cfg(not(windows))]
2034     unimplemented!("Unsupported target OS");
2035 }
2036 #[inline]
MesDecodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, readfn: ::std::option::Option<MIDL_ES_READ>, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS2037 pub unsafe fn MesDecodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, readfn: ::std::option::Option<MIDL_ES_READ>, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
2038     #[cfg(windows)]
2039     {
2040         #[link(name = "windows")]
2041         extern "system" {
2042             fn MesDecodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, readfn: ::windows::runtime::RawPtr, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
2043         }
2044         ::std::mem::transmute(MesDecodeIncrementalHandleCreate(::std::mem::transmute(userstate), ::std::mem::transmute(readfn), ::std::mem::transmute(phandle)))
2045     }
2046     #[cfg(not(windows))]
2047     unimplemented!("Unsupported target OS");
2048 }
2049 #[inline]
MesEncodeDynBufferHandleCreate(pbuffer: *mut *mut i8, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS2050 pub unsafe fn MesEncodeDynBufferHandleCreate(pbuffer: *mut *mut i8, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
2051     #[cfg(windows)]
2052     {
2053         #[link(name = "windows")]
2054         extern "system" {
2055             fn MesEncodeDynBufferHandleCreate(pbuffer: *mut *mut i8, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
2056         }
2057         ::std::mem::transmute(MesEncodeDynBufferHandleCreate(::std::mem::transmute(pbuffer), ::std::mem::transmute(pencodedsize), ::std::mem::transmute(phandle)))
2058     }
2059     #[cfg(not(windows))]
2060     unimplemented!("Unsupported target OS");
2061 }
2062 #[cfg(feature = "Win32_Foundation")]
2063 #[inline]
MesEncodeFixedBufferHandleCreate(pbuffer: super::super::Foundation::PSTR, buffersize: u32, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS2064 pub unsafe fn MesEncodeFixedBufferHandleCreate(pbuffer: super::super::Foundation::PSTR, buffersize: u32, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
2065     #[cfg(windows)]
2066     {
2067         #[link(name = "windows")]
2068         extern "system" {
2069             fn MesEncodeFixedBufferHandleCreate(pbuffer: super::super::Foundation::PSTR, buffersize: u32, pencodedsize: *mut u32, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
2070         }
2071         ::std::mem::transmute(MesEncodeFixedBufferHandleCreate(::std::mem::transmute(pbuffer), ::std::mem::transmute(buffersize), ::std::mem::transmute(pencodedsize), ::std::mem::transmute(phandle)))
2072     }
2073     #[cfg(not(windows))]
2074     unimplemented!("Unsupported target OS");
2075 }
2076 #[cfg(feature = "Win32_Foundation")]
2077 #[inline]
MesEncodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, allocfn: ::std::option::Option<MIDL_ES_ALLOC>, writefn: ::std::option::Option<MIDL_ES_WRITE>, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS2078 pub unsafe fn MesEncodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, allocfn: ::std::option::Option<MIDL_ES_ALLOC>, writefn: ::std::option::Option<MIDL_ES_WRITE>, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
2079     #[cfg(windows)]
2080     {
2081         #[link(name = "windows")]
2082         extern "system" {
2083             fn MesEncodeIncrementalHandleCreate(userstate: *mut ::std::ffi::c_void, allocfn: ::windows::runtime::RawPtr, writefn: ::windows::runtime::RawPtr, phandle: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
2084         }
2085         ::std::mem::transmute(MesEncodeIncrementalHandleCreate(::std::mem::transmute(userstate), ::std::mem::transmute(allocfn), ::std::mem::transmute(writefn), ::std::mem::transmute(phandle)))
2086     }
2087     #[cfg(not(windows))]
2088     unimplemented!("Unsupported target OS");
2089 }
2090 #[inline]
MesHandleFree(handle: *mut ::std::ffi::c_void) -> RPC_STATUS2091 pub unsafe fn MesHandleFree(handle: *mut ::std::ffi::c_void) -> RPC_STATUS {
2092     #[cfg(windows)]
2093     {
2094         #[link(name = "windows")]
2095         extern "system" {
2096             fn MesHandleFree(handle: *mut ::std::ffi::c_void) -> RPC_STATUS;
2097         }
2098         ::std::mem::transmute(MesHandleFree(::std::mem::transmute(handle)))
2099     }
2100     #[cfg(not(windows))]
2101     unimplemented!("Unsupported target OS");
2102 }
2103 #[cfg(feature = "Win32_Foundation")]
2104 #[inline]
MesIncrementalHandleReset(handle: *mut ::std::ffi::c_void, userstate: *mut ::std::ffi::c_void, allocfn: ::std::option::Option<MIDL_ES_ALLOC>, writefn: ::std::option::Option<MIDL_ES_WRITE>, readfn: ::std::option::Option<MIDL_ES_READ>, operation: MIDL_ES_CODE) -> RPC_STATUS2105 pub unsafe fn MesIncrementalHandleReset(handle: *mut ::std::ffi::c_void, userstate: *mut ::std::ffi::c_void, allocfn: ::std::option::Option<MIDL_ES_ALLOC>, writefn: ::std::option::Option<MIDL_ES_WRITE>, readfn: ::std::option::Option<MIDL_ES_READ>, operation: MIDL_ES_CODE) -> RPC_STATUS {
2106     #[cfg(windows)]
2107     {
2108         #[link(name = "windows")]
2109         extern "system" {
2110             fn MesIncrementalHandleReset(handle: *mut ::std::ffi::c_void, userstate: *mut ::std::ffi::c_void, allocfn: ::windows::runtime::RawPtr, writefn: ::windows::runtime::RawPtr, readfn: ::windows::runtime::RawPtr, operation: MIDL_ES_CODE) -> RPC_STATUS;
2111         }
2112         ::std::mem::transmute(MesIncrementalHandleReset(::std::mem::transmute(handle), ::std::mem::transmute(userstate), ::std::mem::transmute(allocfn), ::std::mem::transmute(writefn), ::std::mem::transmute(readfn), ::std::mem::transmute(operation)))
2113     }
2114     #[cfg(not(windows))]
2115     unimplemented!("Unsupported target OS");
2116 }
2117 #[inline]
MesInqProcEncodingId(handle: *mut ::std::ffi::c_void, pinterfaceid: *mut RPC_SYNTAX_IDENTIFIER, pprocnum: *mut u32) -> RPC_STATUS2118 pub unsafe fn MesInqProcEncodingId(handle: *mut ::std::ffi::c_void, pinterfaceid: *mut RPC_SYNTAX_IDENTIFIER, pprocnum: *mut u32) -> RPC_STATUS {
2119     #[cfg(windows)]
2120     {
2121         #[link(name = "windows")]
2122         extern "system" {
2123             fn MesInqProcEncodingId(handle: *mut ::std::ffi::c_void, pinterfaceid: *mut RPC_SYNTAX_IDENTIFIER, pprocnum: *mut u32) -> RPC_STATUS;
2124         }
2125         ::std::mem::transmute(MesInqProcEncodingId(::std::mem::transmute(handle), ::std::mem::transmute(pinterfaceid), ::std::mem::transmute(pprocnum)))
2126     }
2127     #[cfg(not(windows))]
2128     unimplemented!("Unsupported target OS");
2129 }
2130 pub const MidlInterceptionInfoVersionOne: i32 = 1i32;
2131 pub const MidlWinrtTypeSerializationInfoVersionOne: i32 = 1i32;
2132 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2133 #[repr(C)]
2134 pub struct NDR64_ARRAY_ELEMENT_INFO {
2135     pub ElementMemSize: u32,
2136     pub Element: *mut ::std::ffi::c_void,
2137 }
2138 impl NDR64_ARRAY_ELEMENT_INFO {}
2139 impl ::std::default::Default for NDR64_ARRAY_ELEMENT_INFO {
default() -> Self2140     fn default() -> Self {
2141         unsafe { ::std::mem::zeroed() }
2142     }
2143 }
2144 impl ::std::fmt::Debug for NDR64_ARRAY_ELEMENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2145     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2146         fmt.debug_struct("NDR64_ARRAY_ELEMENT_INFO").field("ElementMemSize", &self.ElementMemSize).field("Element", &self.Element).finish()
2147     }
2148 }
2149 impl ::std::cmp::PartialEq for NDR64_ARRAY_ELEMENT_INFO {
eq(&self, other: &Self) -> bool2150     fn eq(&self, other: &Self) -> bool {
2151         self.ElementMemSize == other.ElementMemSize && self.Element == other.Element
2152     }
2153 }
2154 impl ::std::cmp::Eq for NDR64_ARRAY_ELEMENT_INFO {}
2155 unsafe impl ::windows::runtime::Abi for NDR64_ARRAY_ELEMENT_INFO {
2156     type Abi = Self;
2157     type DefaultType = Self;
2158 }
2159 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2160 #[repr(C)]
2161 pub struct NDR64_ARRAY_FLAGS {
2162     pub _bitfield: u8,
2163 }
2164 impl NDR64_ARRAY_FLAGS {}
2165 impl ::std::default::Default for NDR64_ARRAY_FLAGS {
default() -> Self2166     fn default() -> Self {
2167         unsafe { ::std::mem::zeroed() }
2168     }
2169 }
2170 impl ::std::fmt::Debug for NDR64_ARRAY_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2171     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2172         fmt.debug_struct("NDR64_ARRAY_FLAGS").field("_bitfield", &self._bitfield).finish()
2173     }
2174 }
2175 impl ::std::cmp::PartialEq for NDR64_ARRAY_FLAGS {
eq(&self, other: &Self) -> bool2176     fn eq(&self, other: &Self) -> bool {
2177         self._bitfield == other._bitfield
2178     }
2179 }
2180 impl ::std::cmp::Eq for NDR64_ARRAY_FLAGS {}
2181 unsafe impl ::windows::runtime::Abi for NDR64_ARRAY_FLAGS {
2182     type Abi = Self;
2183     type DefaultType = Self;
2184 }
2185 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2186 #[repr(C)]
2187 pub union NDR64_BINDINGS {
2188     pub Primitive: NDR64_BIND_PRIMITIVE,
2189     pub Generic: NDR64_BIND_GENERIC,
2190     pub Context: NDR64_BIND_CONTEXT,
2191 }
2192 impl NDR64_BINDINGS {}
2193 impl ::std::default::Default for NDR64_BINDINGS {
default() -> Self2194     fn default() -> Self {
2195         unsafe { ::std::mem::zeroed() }
2196     }
2197 }
2198 impl ::std::cmp::PartialEq for NDR64_BINDINGS {
eq(&self, _other: &Self) -> bool2199     fn eq(&self, _other: &Self) -> bool {
2200         unimplemented!()
2201     }
2202 }
2203 impl ::std::cmp::Eq for NDR64_BINDINGS {}
2204 unsafe impl ::windows::runtime::Abi for NDR64_BINDINGS {
2205     type Abi = Self;
2206     type DefaultType = Self;
2207 }
2208 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2209 #[repr(C)]
2210 pub struct NDR64_BIND_AND_NOTIFY_EXTENSION {
2211     pub Binding: NDR64_BIND_CONTEXT,
2212     pub NotifyIndex: u16,
2213 }
2214 impl NDR64_BIND_AND_NOTIFY_EXTENSION {}
2215 impl ::std::default::Default for NDR64_BIND_AND_NOTIFY_EXTENSION {
default() -> Self2216     fn default() -> Self {
2217         unsafe { ::std::mem::zeroed() }
2218     }
2219 }
2220 impl ::std::fmt::Debug for NDR64_BIND_AND_NOTIFY_EXTENSION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2221     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2222         fmt.debug_struct("NDR64_BIND_AND_NOTIFY_EXTENSION").field("Binding", &self.Binding).field("NotifyIndex", &self.NotifyIndex).finish()
2223     }
2224 }
2225 impl ::std::cmp::PartialEq for NDR64_BIND_AND_NOTIFY_EXTENSION {
eq(&self, other: &Self) -> bool2226     fn eq(&self, other: &Self) -> bool {
2227         self.Binding == other.Binding && self.NotifyIndex == other.NotifyIndex
2228     }
2229 }
2230 impl ::std::cmp::Eq for NDR64_BIND_AND_NOTIFY_EXTENSION {}
2231 unsafe impl ::windows::runtime::Abi for NDR64_BIND_AND_NOTIFY_EXTENSION {
2232     type Abi = Self;
2233     type DefaultType = Self;
2234 }
2235 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2236 #[repr(C)]
2237 pub struct NDR64_BIND_CONTEXT {
2238     pub HandleType: u8,
2239     pub Flags: u8,
2240     pub StackOffset: u16,
2241     pub RoutineIndex: u8,
2242     pub Ordinal: u8,
2243 }
2244 impl NDR64_BIND_CONTEXT {}
2245 impl ::std::default::Default for NDR64_BIND_CONTEXT {
default() -> Self2246     fn default() -> Self {
2247         unsafe { ::std::mem::zeroed() }
2248     }
2249 }
2250 impl ::std::fmt::Debug for NDR64_BIND_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2251     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2252         fmt.debug_struct("NDR64_BIND_CONTEXT").field("HandleType", &self.HandleType).field("Flags", &self.Flags).field("StackOffset", &self.StackOffset).field("RoutineIndex", &self.RoutineIndex).field("Ordinal", &self.Ordinal).finish()
2253     }
2254 }
2255 impl ::std::cmp::PartialEq for NDR64_BIND_CONTEXT {
eq(&self, other: &Self) -> bool2256     fn eq(&self, other: &Self) -> bool {
2257         self.HandleType == other.HandleType && self.Flags == other.Flags && self.StackOffset == other.StackOffset && self.RoutineIndex == other.RoutineIndex && self.Ordinal == other.Ordinal
2258     }
2259 }
2260 impl ::std::cmp::Eq for NDR64_BIND_CONTEXT {}
2261 unsafe impl ::windows::runtime::Abi for NDR64_BIND_CONTEXT {
2262     type Abi = Self;
2263     type DefaultType = Self;
2264 }
2265 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2266 #[repr(C)]
2267 pub struct NDR64_BIND_GENERIC {
2268     pub HandleType: u8,
2269     pub Flags: u8,
2270     pub StackOffset: u16,
2271     pub RoutineIndex: u8,
2272     pub Size: u8,
2273 }
2274 impl NDR64_BIND_GENERIC {}
2275 impl ::std::default::Default for NDR64_BIND_GENERIC {
default() -> Self2276     fn default() -> Self {
2277         unsafe { ::std::mem::zeroed() }
2278     }
2279 }
2280 impl ::std::fmt::Debug for NDR64_BIND_GENERIC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2281     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2282         fmt.debug_struct("NDR64_BIND_GENERIC").field("HandleType", &self.HandleType).field("Flags", &self.Flags).field("StackOffset", &self.StackOffset).field("RoutineIndex", &self.RoutineIndex).field("Size", &self.Size).finish()
2283     }
2284 }
2285 impl ::std::cmp::PartialEq for NDR64_BIND_GENERIC {
eq(&self, other: &Self) -> bool2286     fn eq(&self, other: &Self) -> bool {
2287         self.HandleType == other.HandleType && self.Flags == other.Flags && self.StackOffset == other.StackOffset && self.RoutineIndex == other.RoutineIndex && self.Size == other.Size
2288     }
2289 }
2290 impl ::std::cmp::Eq for NDR64_BIND_GENERIC {}
2291 unsafe impl ::windows::runtime::Abi for NDR64_BIND_GENERIC {
2292     type Abi = Self;
2293     type DefaultType = Self;
2294 }
2295 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2296 #[repr(C)]
2297 pub struct NDR64_BIND_PRIMITIVE {
2298     pub HandleType: u8,
2299     pub Flags: u8,
2300     pub StackOffset: u16,
2301     pub Reserved: u16,
2302 }
2303 impl NDR64_BIND_PRIMITIVE {}
2304 impl ::std::default::Default for NDR64_BIND_PRIMITIVE {
default() -> Self2305     fn default() -> Self {
2306         unsafe { ::std::mem::zeroed() }
2307     }
2308 }
2309 impl ::std::fmt::Debug for NDR64_BIND_PRIMITIVE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2310     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2311         fmt.debug_struct("NDR64_BIND_PRIMITIVE").field("HandleType", &self.HandleType).field("Flags", &self.Flags).field("StackOffset", &self.StackOffset).field("Reserved", &self.Reserved).finish()
2312     }
2313 }
2314 impl ::std::cmp::PartialEq for NDR64_BIND_PRIMITIVE {
eq(&self, other: &Self) -> bool2315     fn eq(&self, other: &Self) -> bool {
2316         self.HandleType == other.HandleType && self.Flags == other.Flags && self.StackOffset == other.StackOffset && self.Reserved == other.Reserved
2317     }
2318 }
2319 impl ::std::cmp::Eq for NDR64_BIND_PRIMITIVE {}
2320 unsafe impl ::windows::runtime::Abi for NDR64_BIND_PRIMITIVE {
2321     type Abi = Self;
2322     type DefaultType = Self;
2323 }
2324 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2325 #[repr(C)]
2326 pub struct NDR64_BOGUS_ARRAY_HEADER_FORMAT {
2327     pub FormatCode: u8,
2328     pub Alignment: u8,
2329     pub Flags: NDR64_ARRAY_FLAGS,
2330     pub NumberDims: u8,
2331     pub NumberElements: u32,
2332     pub Element: *mut ::std::ffi::c_void,
2333 }
2334 impl NDR64_BOGUS_ARRAY_HEADER_FORMAT {}
2335 impl ::std::default::Default for NDR64_BOGUS_ARRAY_HEADER_FORMAT {
default() -> Self2336     fn default() -> Self {
2337         unsafe { ::std::mem::zeroed() }
2338     }
2339 }
2340 impl ::std::fmt::Debug for NDR64_BOGUS_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2341     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2342         fmt.debug_struct("NDR64_BOGUS_ARRAY_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("NumberDims", &self.NumberDims).field("NumberElements", &self.NumberElements).field("Element", &self.Element).finish()
2343     }
2344 }
2345 impl ::std::cmp::PartialEq for NDR64_BOGUS_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2346     fn eq(&self, other: &Self) -> bool {
2347         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.NumberDims == other.NumberDims && self.NumberElements == other.NumberElements && self.Element == other.Element
2348     }
2349 }
2350 impl ::std::cmp::Eq for NDR64_BOGUS_ARRAY_HEADER_FORMAT {}
2351 unsafe impl ::windows::runtime::Abi for NDR64_BOGUS_ARRAY_HEADER_FORMAT {
2352     type Abi = Self;
2353     type DefaultType = Self;
2354 }
2355 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2356 #[repr(C)]
2357 pub struct NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {
2358     pub FormatCode: u8,
2359     pub Alignment: u8,
2360     pub Flags: NDR64_STRUCTURE_FLAGS,
2361     pub Reserve: u8,
2362     pub MemorySize: u32,
2363     pub OriginalMemberLayout: *mut ::std::ffi::c_void,
2364     pub OriginalPointerLayout: *mut ::std::ffi::c_void,
2365     pub PointerLayout: *mut ::std::ffi::c_void,
2366 }
2367 impl NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {}
2368 impl ::std::default::Default for NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {
default() -> Self2369     fn default() -> Self {
2370         unsafe { ::std::mem::zeroed() }
2371     }
2372 }
2373 impl ::std::fmt::Debug for NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2374     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2375         fmt.debug_struct("NDR64_BOGUS_STRUCTURE_HEADER_FORMAT")
2376             .field("FormatCode", &self.FormatCode)
2377             .field("Alignment", &self.Alignment)
2378             .field("Flags", &self.Flags)
2379             .field("Reserve", &self.Reserve)
2380             .field("MemorySize", &self.MemorySize)
2381             .field("OriginalMemberLayout", &self.OriginalMemberLayout)
2382             .field("OriginalPointerLayout", &self.OriginalPointerLayout)
2383             .field("PointerLayout", &self.PointerLayout)
2384             .finish()
2385     }
2386 }
2387 impl ::std::cmp::PartialEq for NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2388     fn eq(&self, other: &Self) -> bool {
2389         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserve == other.Reserve && self.MemorySize == other.MemorySize && self.OriginalMemberLayout == other.OriginalMemberLayout && self.OriginalPointerLayout == other.OriginalPointerLayout && self.PointerLayout == other.PointerLayout
2390     }
2391 }
2392 impl ::std::cmp::Eq for NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {}
2393 unsafe impl ::windows::runtime::Abi for NDR64_BOGUS_STRUCTURE_HEADER_FORMAT {
2394     type Abi = Self;
2395     type DefaultType = Self;
2396 }
2397 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2398 #[repr(C)]
2399 pub struct NDR64_BUFFER_ALIGN_FORMAT {
2400     pub FormatCode: u8,
2401     pub Alignment: u8,
2402     pub Reserved: u16,
2403     pub Reserved2: u32,
2404 }
2405 impl NDR64_BUFFER_ALIGN_FORMAT {}
2406 impl ::std::default::Default for NDR64_BUFFER_ALIGN_FORMAT {
default() -> Self2407     fn default() -> Self {
2408         unsafe { ::std::mem::zeroed() }
2409     }
2410 }
2411 impl ::std::fmt::Debug for NDR64_BUFFER_ALIGN_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2412     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2413         fmt.debug_struct("NDR64_BUFFER_ALIGN_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Reserved", &self.Reserved).field("Reserved2", &self.Reserved2).finish()
2414     }
2415 }
2416 impl ::std::cmp::PartialEq for NDR64_BUFFER_ALIGN_FORMAT {
eq(&self, other: &Self) -> bool2417     fn eq(&self, other: &Self) -> bool {
2418         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Reserved == other.Reserved && self.Reserved2 == other.Reserved2
2419     }
2420 }
2421 impl ::std::cmp::Eq for NDR64_BUFFER_ALIGN_FORMAT {}
2422 unsafe impl ::windows::runtime::Abi for NDR64_BUFFER_ALIGN_FORMAT {
2423     type Abi = Self;
2424     type DefaultType = Self;
2425 }
2426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2427 #[repr(C)]
2428 pub struct NDR64_CONFORMANT_STRING_FORMAT {
2429     pub Header: NDR64_STRING_HEADER_FORMAT,
2430 }
2431 impl NDR64_CONFORMANT_STRING_FORMAT {}
2432 impl ::std::default::Default for NDR64_CONFORMANT_STRING_FORMAT {
default() -> Self2433     fn default() -> Self {
2434         unsafe { ::std::mem::zeroed() }
2435     }
2436 }
2437 impl ::std::fmt::Debug for NDR64_CONFORMANT_STRING_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2438     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2439         fmt.debug_struct("NDR64_CONFORMANT_STRING_FORMAT").field("Header", &self.Header).finish()
2440     }
2441 }
2442 impl ::std::cmp::PartialEq for NDR64_CONFORMANT_STRING_FORMAT {
eq(&self, other: &Self) -> bool2443     fn eq(&self, other: &Self) -> bool {
2444         self.Header == other.Header
2445     }
2446 }
2447 impl ::std::cmp::Eq for NDR64_CONFORMANT_STRING_FORMAT {}
2448 unsafe impl ::windows::runtime::Abi for NDR64_CONFORMANT_STRING_FORMAT {
2449     type Abi = Self;
2450     type DefaultType = Self;
2451 }
2452 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2453 #[repr(C)]
2454 pub struct NDR64_CONF_ARRAY_HEADER_FORMAT {
2455     pub FormatCode: u8,
2456     pub Alignment: u8,
2457     pub Flags: NDR64_ARRAY_FLAGS,
2458     pub Reserved: u8,
2459     pub ElementSize: u32,
2460     pub ConfDescriptor: *mut ::std::ffi::c_void,
2461 }
2462 impl NDR64_CONF_ARRAY_HEADER_FORMAT {}
2463 impl ::std::default::Default for NDR64_CONF_ARRAY_HEADER_FORMAT {
default() -> Self2464     fn default() -> Self {
2465         unsafe { ::std::mem::zeroed() }
2466     }
2467 }
2468 impl ::std::fmt::Debug for NDR64_CONF_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2469     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2470         fmt.debug_struct("NDR64_CONF_ARRAY_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("ElementSize", &self.ElementSize).field("ConfDescriptor", &self.ConfDescriptor).finish()
2471     }
2472 }
2473 impl ::std::cmp::PartialEq for NDR64_CONF_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2474     fn eq(&self, other: &Self) -> bool {
2475         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserved == other.Reserved && self.ElementSize == other.ElementSize && self.ConfDescriptor == other.ConfDescriptor
2476     }
2477 }
2478 impl ::std::cmp::Eq for NDR64_CONF_ARRAY_HEADER_FORMAT {}
2479 unsafe impl ::windows::runtime::Abi for NDR64_CONF_ARRAY_HEADER_FORMAT {
2480     type Abi = Self;
2481     type DefaultType = Self;
2482 }
2483 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2484 #[repr(C)]
2485 pub struct NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {
2486     pub FormatCode: u8,
2487     pub Alignment: u8,
2488     pub Flags: NDR64_STRUCTURE_FLAGS,
2489     pub Dimensions: u8,
2490     pub MemorySize: u32,
2491     pub OriginalMemberLayout: *mut ::std::ffi::c_void,
2492     pub OriginalPointerLayout: *mut ::std::ffi::c_void,
2493     pub PointerLayout: *mut ::std::ffi::c_void,
2494     pub ConfArrayDescription: *mut ::std::ffi::c_void,
2495 }
2496 impl NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {}
2497 impl ::std::default::Default for NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {
default() -> Self2498     fn default() -> Self {
2499         unsafe { ::std::mem::zeroed() }
2500     }
2501 }
2502 impl ::std::fmt::Debug for NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2503     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2504         fmt.debug_struct("NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT")
2505             .field("FormatCode", &self.FormatCode)
2506             .field("Alignment", &self.Alignment)
2507             .field("Flags", &self.Flags)
2508             .field("Dimensions", &self.Dimensions)
2509             .field("MemorySize", &self.MemorySize)
2510             .field("OriginalMemberLayout", &self.OriginalMemberLayout)
2511             .field("OriginalPointerLayout", &self.OriginalPointerLayout)
2512             .field("PointerLayout", &self.PointerLayout)
2513             .field("ConfArrayDescription", &self.ConfArrayDescription)
2514             .finish()
2515     }
2516 }
2517 impl ::std::cmp::PartialEq for NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2518     fn eq(&self, other: &Self) -> bool {
2519         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Dimensions == other.Dimensions && self.MemorySize == other.MemorySize && self.OriginalMemberLayout == other.OriginalMemberLayout && self.OriginalPointerLayout == other.OriginalPointerLayout && self.PointerLayout == other.PointerLayout && self.ConfArrayDescription == other.ConfArrayDescription
2520     }
2521 }
2522 impl ::std::cmp::Eq for NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {}
2523 unsafe impl ::windows::runtime::Abi for NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT {
2524     type Abi = Self;
2525     type DefaultType = Self;
2526 }
2527 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2528 #[repr(C)]
2529 pub struct NDR64_CONF_STRUCTURE_HEADER_FORMAT {
2530     pub FormatCode: u8,
2531     pub Alignment: u8,
2532     pub Flags: NDR64_STRUCTURE_FLAGS,
2533     pub Reserve: u8,
2534     pub MemorySize: u32,
2535     pub ArrayDescription: *mut ::std::ffi::c_void,
2536 }
2537 impl NDR64_CONF_STRUCTURE_HEADER_FORMAT {}
2538 impl ::std::default::Default for NDR64_CONF_STRUCTURE_HEADER_FORMAT {
default() -> Self2539     fn default() -> Self {
2540         unsafe { ::std::mem::zeroed() }
2541     }
2542 }
2543 impl ::std::fmt::Debug for NDR64_CONF_STRUCTURE_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2544     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2545         fmt.debug_struct("NDR64_CONF_STRUCTURE_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("Reserve", &self.Reserve).field("MemorySize", &self.MemorySize).field("ArrayDescription", &self.ArrayDescription).finish()
2546     }
2547 }
2548 impl ::std::cmp::PartialEq for NDR64_CONF_STRUCTURE_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2549     fn eq(&self, other: &Self) -> bool {
2550         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserve == other.Reserve && self.MemorySize == other.MemorySize && self.ArrayDescription == other.ArrayDescription
2551     }
2552 }
2553 impl ::std::cmp::Eq for NDR64_CONF_STRUCTURE_HEADER_FORMAT {}
2554 unsafe impl ::windows::runtime::Abi for NDR64_CONF_STRUCTURE_HEADER_FORMAT {
2555     type Abi = Self;
2556     type DefaultType = Self;
2557 }
2558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2559 #[repr(C)]
2560 pub struct NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {
2561     pub FormatCode: u8,
2562     pub Alignment: u8,
2563     pub Flags: NDR64_ARRAY_FLAGS,
2564     pub Reserved: u8,
2565     pub ElementSize: u32,
2566     pub ConfDescriptor: *mut ::std::ffi::c_void,
2567     pub VarDescriptor: *mut ::std::ffi::c_void,
2568 }
2569 impl NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {}
2570 impl ::std::default::Default for NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {
default() -> Self2571     fn default() -> Self {
2572         unsafe { ::std::mem::zeroed() }
2573     }
2574 }
2575 impl ::std::fmt::Debug for NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2576     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2577         fmt.debug_struct("NDR64_CONF_VAR_ARRAY_HEADER_FORMAT")
2578             .field("FormatCode", &self.FormatCode)
2579             .field("Alignment", &self.Alignment)
2580             .field("Flags", &self.Flags)
2581             .field("Reserved", &self.Reserved)
2582             .field("ElementSize", &self.ElementSize)
2583             .field("ConfDescriptor", &self.ConfDescriptor)
2584             .field("VarDescriptor", &self.VarDescriptor)
2585             .finish()
2586     }
2587 }
2588 impl ::std::cmp::PartialEq for NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2589     fn eq(&self, other: &Self) -> bool {
2590         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserved == other.Reserved && self.ElementSize == other.ElementSize && self.ConfDescriptor == other.ConfDescriptor && self.VarDescriptor == other.VarDescriptor
2591     }
2592 }
2593 impl ::std::cmp::Eq for NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {}
2594 unsafe impl ::windows::runtime::Abi for NDR64_CONF_VAR_ARRAY_HEADER_FORMAT {
2595     type Abi = Self;
2596     type DefaultType = Self;
2597 }
2598 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2599 #[repr(C)]
2600 pub struct NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {
2601     pub FixedArrayFormat: NDR64_BOGUS_ARRAY_HEADER_FORMAT,
2602     pub ConfDescription: *mut ::std::ffi::c_void,
2603     pub VarDescription: *mut ::std::ffi::c_void,
2604     pub OffsetDescription: *mut ::std::ffi::c_void,
2605 }
2606 impl NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {}
2607 impl ::std::default::Default for NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {
default() -> Self2608     fn default() -> Self {
2609         unsafe { ::std::mem::zeroed() }
2610     }
2611 }
2612 impl ::std::fmt::Debug for NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2613     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2614         fmt.debug_struct("NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT").field("FixedArrayFormat", &self.FixedArrayFormat).field("ConfDescription", &self.ConfDescription).field("VarDescription", &self.VarDescription).field("OffsetDescription", &self.OffsetDescription).finish()
2615     }
2616 }
2617 impl ::std::cmp::PartialEq for NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2618     fn eq(&self, other: &Self) -> bool {
2619         self.FixedArrayFormat == other.FixedArrayFormat && self.ConfDescription == other.ConfDescription && self.VarDescription == other.VarDescription && self.OffsetDescription == other.OffsetDescription
2620     }
2621 }
2622 impl ::std::cmp::Eq for NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {}
2623 unsafe impl ::windows::runtime::Abi for NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT {
2624     type Abi = Self;
2625     type DefaultType = Self;
2626 }
2627 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2628 #[repr(C)]
2629 pub struct NDR64_CONSTANT_IID_FORMAT {
2630     pub FormatCode: u8,
2631     pub Flags: u8,
2632     pub Reserved: u16,
2633     pub Guid: ::windows::runtime::GUID,
2634 }
2635 impl NDR64_CONSTANT_IID_FORMAT {}
2636 impl ::std::default::Default for NDR64_CONSTANT_IID_FORMAT {
default() -> Self2637     fn default() -> Self {
2638         unsafe { ::std::mem::zeroed() }
2639     }
2640 }
2641 impl ::std::fmt::Debug for NDR64_CONSTANT_IID_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2642     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2643         fmt.debug_struct("NDR64_CONSTANT_IID_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("Guid", &self.Guid).finish()
2644     }
2645 }
2646 impl ::std::cmp::PartialEq for NDR64_CONSTANT_IID_FORMAT {
eq(&self, other: &Self) -> bool2647     fn eq(&self, other: &Self) -> bool {
2648         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Reserved == other.Reserved && self.Guid == other.Guid
2649     }
2650 }
2651 impl ::std::cmp::Eq for NDR64_CONSTANT_IID_FORMAT {}
2652 unsafe impl ::windows::runtime::Abi for NDR64_CONSTANT_IID_FORMAT {
2653     type Abi = Self;
2654     type DefaultType = Self;
2655 }
2656 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2657 #[repr(C)]
2658 pub struct NDR64_CONTEXT_HANDLE_FLAGS {
2659     pub _bitfield: u8,
2660 }
2661 impl NDR64_CONTEXT_HANDLE_FLAGS {}
2662 impl ::std::default::Default for NDR64_CONTEXT_HANDLE_FLAGS {
default() -> Self2663     fn default() -> Self {
2664         unsafe { ::std::mem::zeroed() }
2665     }
2666 }
2667 impl ::std::fmt::Debug for NDR64_CONTEXT_HANDLE_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2668     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2669         fmt.debug_struct("NDR64_CONTEXT_HANDLE_FLAGS").field("_bitfield", &self._bitfield).finish()
2670     }
2671 }
2672 impl ::std::cmp::PartialEq for NDR64_CONTEXT_HANDLE_FLAGS {
eq(&self, other: &Self) -> bool2673     fn eq(&self, other: &Self) -> bool {
2674         self._bitfield == other._bitfield
2675     }
2676 }
2677 impl ::std::cmp::Eq for NDR64_CONTEXT_HANDLE_FLAGS {}
2678 unsafe impl ::windows::runtime::Abi for NDR64_CONTEXT_HANDLE_FLAGS {
2679     type Abi = Self;
2680     type DefaultType = Self;
2681 }
2682 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2683 #[repr(C)]
2684 pub struct NDR64_CONTEXT_HANDLE_FORMAT {
2685     pub FormatCode: u8,
2686     pub ContextFlags: u8,
2687     pub RundownRoutineIndex: u8,
2688     pub Ordinal: u8,
2689 }
2690 impl NDR64_CONTEXT_HANDLE_FORMAT {}
2691 impl ::std::default::Default for NDR64_CONTEXT_HANDLE_FORMAT {
default() -> Self2692     fn default() -> Self {
2693         unsafe { ::std::mem::zeroed() }
2694     }
2695 }
2696 impl ::std::fmt::Debug for NDR64_CONTEXT_HANDLE_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2697     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2698         fmt.debug_struct("NDR64_CONTEXT_HANDLE_FORMAT").field("FormatCode", &self.FormatCode).field("ContextFlags", &self.ContextFlags).field("RundownRoutineIndex", &self.RundownRoutineIndex).field("Ordinal", &self.Ordinal).finish()
2699     }
2700 }
2701 impl ::std::cmp::PartialEq for NDR64_CONTEXT_HANDLE_FORMAT {
eq(&self, other: &Self) -> bool2702     fn eq(&self, other: &Self) -> bool {
2703         self.FormatCode == other.FormatCode && self.ContextFlags == other.ContextFlags && self.RundownRoutineIndex == other.RundownRoutineIndex && self.Ordinal == other.Ordinal
2704     }
2705 }
2706 impl ::std::cmp::Eq for NDR64_CONTEXT_HANDLE_FORMAT {}
2707 unsafe impl ::windows::runtime::Abi for NDR64_CONTEXT_HANDLE_FORMAT {
2708     type Abi = Self;
2709     type DefaultType = Self;
2710 }
2711 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2712 #[repr(C)]
2713 pub struct NDR64_EMBEDDED_COMPLEX_FORMAT {
2714     pub FormatCode: u8,
2715     pub Reserve1: u8,
2716     pub Reserve2: u16,
2717     pub Type: *mut ::std::ffi::c_void,
2718 }
2719 impl NDR64_EMBEDDED_COMPLEX_FORMAT {}
2720 impl ::std::default::Default for NDR64_EMBEDDED_COMPLEX_FORMAT {
default() -> Self2721     fn default() -> Self {
2722         unsafe { ::std::mem::zeroed() }
2723     }
2724 }
2725 impl ::std::fmt::Debug for NDR64_EMBEDDED_COMPLEX_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2726     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2727         fmt.debug_struct("NDR64_EMBEDDED_COMPLEX_FORMAT").field("FormatCode", &self.FormatCode).field("Reserve1", &self.Reserve1).field("Reserve2", &self.Reserve2).field("Type", &self.Type).finish()
2728     }
2729 }
2730 impl ::std::cmp::PartialEq for NDR64_EMBEDDED_COMPLEX_FORMAT {
eq(&self, other: &Self) -> bool2731     fn eq(&self, other: &Self) -> bool {
2732         self.FormatCode == other.FormatCode && self.Reserve1 == other.Reserve1 && self.Reserve2 == other.Reserve2 && self.Type == other.Type
2733     }
2734 }
2735 impl ::std::cmp::Eq for NDR64_EMBEDDED_COMPLEX_FORMAT {}
2736 unsafe impl ::windows::runtime::Abi for NDR64_EMBEDDED_COMPLEX_FORMAT {
2737     type Abi = Self;
2738     type DefaultType = Self;
2739 }
2740 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2741 #[repr(C)]
2742 pub struct NDR64_ENCAPSULATED_UNION {
2743     pub FormatCode: u8,
2744     pub Alignment: u8,
2745     pub Flags: u8,
2746     pub SwitchType: u8,
2747     pub MemoryOffset: u32,
2748     pub MemorySize: u32,
2749     pub Reserved: u32,
2750 }
2751 impl NDR64_ENCAPSULATED_UNION {}
2752 impl ::std::default::Default for NDR64_ENCAPSULATED_UNION {
default() -> Self2753     fn default() -> Self {
2754         unsafe { ::std::mem::zeroed() }
2755     }
2756 }
2757 impl ::std::fmt::Debug for NDR64_ENCAPSULATED_UNION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2758     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2759         fmt.debug_struct("NDR64_ENCAPSULATED_UNION")
2760             .field("FormatCode", &self.FormatCode)
2761             .field("Alignment", &self.Alignment)
2762             .field("Flags", &self.Flags)
2763             .field("SwitchType", &self.SwitchType)
2764             .field("MemoryOffset", &self.MemoryOffset)
2765             .field("MemorySize", &self.MemorySize)
2766             .field("Reserved", &self.Reserved)
2767             .finish()
2768     }
2769 }
2770 impl ::std::cmp::PartialEq for NDR64_ENCAPSULATED_UNION {
eq(&self, other: &Self) -> bool2771     fn eq(&self, other: &Self) -> bool {
2772         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.SwitchType == other.SwitchType && self.MemoryOffset == other.MemoryOffset && self.MemorySize == other.MemorySize && self.Reserved == other.Reserved
2773     }
2774 }
2775 impl ::std::cmp::Eq for NDR64_ENCAPSULATED_UNION {}
2776 unsafe impl ::windows::runtime::Abi for NDR64_ENCAPSULATED_UNION {
2777     type Abi = Self;
2778     type DefaultType = Self;
2779 }
2780 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2781 #[repr(C)]
2782 pub struct NDR64_EXPR_CONST32 {
2783     pub ExprType: u8,
2784     pub Reserved: u8,
2785     pub Reserved1: u16,
2786     pub ConstValue: u32,
2787 }
2788 impl NDR64_EXPR_CONST32 {}
2789 impl ::std::default::Default for NDR64_EXPR_CONST32 {
default() -> Self2790     fn default() -> Self {
2791         unsafe { ::std::mem::zeroed() }
2792     }
2793 }
2794 impl ::std::fmt::Debug for NDR64_EXPR_CONST32 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2795     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2796         fmt.debug_struct("NDR64_EXPR_CONST32").field("ExprType", &self.ExprType).field("Reserved", &self.Reserved).field("Reserved1", &self.Reserved1).field("ConstValue", &self.ConstValue).finish()
2797     }
2798 }
2799 impl ::std::cmp::PartialEq for NDR64_EXPR_CONST32 {
eq(&self, other: &Self) -> bool2800     fn eq(&self, other: &Self) -> bool {
2801         self.ExprType == other.ExprType && self.Reserved == other.Reserved && self.Reserved1 == other.Reserved1 && self.ConstValue == other.ConstValue
2802     }
2803 }
2804 impl ::std::cmp::Eq for NDR64_EXPR_CONST32 {}
2805 unsafe impl ::windows::runtime::Abi for NDR64_EXPR_CONST32 {
2806     type Abi = Self;
2807     type DefaultType = Self;
2808 }
2809 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2810 #[repr(C)]
2811 pub struct NDR64_EXPR_CONST64 {
2812     pub ExprType: u8,
2813     pub Reserved: u8,
2814     pub Reserved1: u16,
2815     pub ConstValue: i64,
2816 }
2817 impl NDR64_EXPR_CONST64 {}
2818 impl ::std::default::Default for NDR64_EXPR_CONST64 {
default() -> Self2819     fn default() -> Self {
2820         unsafe { ::std::mem::zeroed() }
2821     }
2822 }
2823 impl ::std::fmt::Debug for NDR64_EXPR_CONST64 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2824     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2825         fmt.debug_struct("NDR64_EXPR_CONST64").field("ExprType", &self.ExprType).field("Reserved", &self.Reserved).field("Reserved1", &self.Reserved1).field("ConstValue", &self.ConstValue).finish()
2826     }
2827 }
2828 impl ::std::cmp::PartialEq for NDR64_EXPR_CONST64 {
eq(&self, other: &Self) -> bool2829     fn eq(&self, other: &Self) -> bool {
2830         self.ExprType == other.ExprType && self.Reserved == other.Reserved && self.Reserved1 == other.Reserved1 && self.ConstValue == other.ConstValue
2831     }
2832 }
2833 impl ::std::cmp::Eq for NDR64_EXPR_CONST64 {}
2834 unsafe impl ::windows::runtime::Abi for NDR64_EXPR_CONST64 {
2835     type Abi = Self;
2836     type DefaultType = Self;
2837 }
2838 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2839 #[repr(C)]
2840 pub struct NDR64_EXPR_NOOP {
2841     pub ExprType: u8,
2842     pub Size: u8,
2843     pub Reserved: u16,
2844 }
2845 impl NDR64_EXPR_NOOP {}
2846 impl ::std::default::Default for NDR64_EXPR_NOOP {
default() -> Self2847     fn default() -> Self {
2848         unsafe { ::std::mem::zeroed() }
2849     }
2850 }
2851 impl ::std::fmt::Debug for NDR64_EXPR_NOOP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2852     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2853         fmt.debug_struct("NDR64_EXPR_NOOP").field("ExprType", &self.ExprType).field("Size", &self.Size).field("Reserved", &self.Reserved).finish()
2854     }
2855 }
2856 impl ::std::cmp::PartialEq for NDR64_EXPR_NOOP {
eq(&self, other: &Self) -> bool2857     fn eq(&self, other: &Self) -> bool {
2858         self.ExprType == other.ExprType && self.Size == other.Size && self.Reserved == other.Reserved
2859     }
2860 }
2861 impl ::std::cmp::Eq for NDR64_EXPR_NOOP {}
2862 unsafe impl ::windows::runtime::Abi for NDR64_EXPR_NOOP {
2863     type Abi = Self;
2864     type DefaultType = Self;
2865 }
2866 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2867 #[repr(C)]
2868 pub struct NDR64_EXPR_OPERATOR {
2869     pub ExprType: u8,
2870     pub Operator: u8,
2871     pub CastType: u8,
2872     pub Reserved: u8,
2873 }
2874 impl NDR64_EXPR_OPERATOR {}
2875 impl ::std::default::Default for NDR64_EXPR_OPERATOR {
default() -> Self2876     fn default() -> Self {
2877         unsafe { ::std::mem::zeroed() }
2878     }
2879 }
2880 impl ::std::fmt::Debug for NDR64_EXPR_OPERATOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2881     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2882         fmt.debug_struct("NDR64_EXPR_OPERATOR").field("ExprType", &self.ExprType).field("Operator", &self.Operator).field("CastType", &self.CastType).field("Reserved", &self.Reserved).finish()
2883     }
2884 }
2885 impl ::std::cmp::PartialEq for NDR64_EXPR_OPERATOR {
eq(&self, other: &Self) -> bool2886     fn eq(&self, other: &Self) -> bool {
2887         self.ExprType == other.ExprType && self.Operator == other.Operator && self.CastType == other.CastType && self.Reserved == other.Reserved
2888     }
2889 }
2890 impl ::std::cmp::Eq for NDR64_EXPR_OPERATOR {}
2891 unsafe impl ::windows::runtime::Abi for NDR64_EXPR_OPERATOR {
2892     type Abi = Self;
2893     type DefaultType = Self;
2894 }
2895 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2896 #[repr(C)]
2897 pub struct NDR64_EXPR_VAR {
2898     pub ExprType: u8,
2899     pub VarType: u8,
2900     pub Reserved: u16,
2901     pub Offset: u32,
2902 }
2903 impl NDR64_EXPR_VAR {}
2904 impl ::std::default::Default for NDR64_EXPR_VAR {
default() -> Self2905     fn default() -> Self {
2906         unsafe { ::std::mem::zeroed() }
2907     }
2908 }
2909 impl ::std::fmt::Debug for NDR64_EXPR_VAR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2910     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2911         fmt.debug_struct("NDR64_EXPR_VAR").field("ExprType", &self.ExprType).field("VarType", &self.VarType).field("Reserved", &self.Reserved).field("Offset", &self.Offset).finish()
2912     }
2913 }
2914 impl ::std::cmp::PartialEq for NDR64_EXPR_VAR {
eq(&self, other: &Self) -> bool2915     fn eq(&self, other: &Self) -> bool {
2916         self.ExprType == other.ExprType && self.VarType == other.VarType && self.Reserved == other.Reserved && self.Offset == other.Offset
2917     }
2918 }
2919 impl ::std::cmp::Eq for NDR64_EXPR_VAR {}
2920 unsafe impl ::windows::runtime::Abi for NDR64_EXPR_VAR {
2921     type Abi = Self;
2922     type DefaultType = Self;
2923 }
2924 pub const NDR64_FC_AUTO_HANDLE: u32 = 3u32;
2925 pub const NDR64_FC_BIND_GENERIC: u32 = 1u32;
2926 pub const NDR64_FC_BIND_PRIMITIVE: u32 = 2u32;
2927 pub const NDR64_FC_CALLBACK_HANDLE: u32 = 4u32;
2928 pub const NDR64_FC_EXPLICIT_HANDLE: u32 = 0u32;
2929 pub const NDR64_FC_NO_HANDLE: u32 = 5u32;
2930 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2931 #[repr(C)]
2932 pub struct NDR64_FIXED_REPEAT_FORMAT {
2933     pub RepeatFormat: NDR64_REPEAT_FORMAT,
2934     pub Iterations: u32,
2935     pub Reserved: u32,
2936 }
2937 impl NDR64_FIXED_REPEAT_FORMAT {}
2938 impl ::std::default::Default for NDR64_FIXED_REPEAT_FORMAT {
default() -> Self2939     fn default() -> Self {
2940         unsafe { ::std::mem::zeroed() }
2941     }
2942 }
2943 impl ::std::fmt::Debug for NDR64_FIXED_REPEAT_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2944     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2945         fmt.debug_struct("NDR64_FIXED_REPEAT_FORMAT").field("RepeatFormat", &self.RepeatFormat).field("Iterations", &self.Iterations).field("Reserved", &self.Reserved).finish()
2946     }
2947 }
2948 impl ::std::cmp::PartialEq for NDR64_FIXED_REPEAT_FORMAT {
eq(&self, other: &Self) -> bool2949     fn eq(&self, other: &Self) -> bool {
2950         self.RepeatFormat == other.RepeatFormat && self.Iterations == other.Iterations && self.Reserved == other.Reserved
2951     }
2952 }
2953 impl ::std::cmp::Eq for NDR64_FIXED_REPEAT_FORMAT {}
2954 unsafe impl ::windows::runtime::Abi for NDR64_FIXED_REPEAT_FORMAT {
2955     type Abi = Self;
2956     type DefaultType = Self;
2957 }
2958 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2959 #[repr(C)]
2960 pub struct NDR64_FIX_ARRAY_HEADER_FORMAT {
2961     pub FormatCode: u8,
2962     pub Alignment: u8,
2963     pub Flags: NDR64_ARRAY_FLAGS,
2964     pub Reserved: u8,
2965     pub TotalSize: u32,
2966 }
2967 impl NDR64_FIX_ARRAY_HEADER_FORMAT {}
2968 impl ::std::default::Default for NDR64_FIX_ARRAY_HEADER_FORMAT {
default() -> Self2969     fn default() -> Self {
2970         unsafe { ::std::mem::zeroed() }
2971     }
2972 }
2973 impl ::std::fmt::Debug for NDR64_FIX_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2974     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2975         fmt.debug_struct("NDR64_FIX_ARRAY_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("TotalSize", &self.TotalSize).finish()
2976     }
2977 }
2978 impl ::std::cmp::PartialEq for NDR64_FIX_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool2979     fn eq(&self, other: &Self) -> bool {
2980         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserved == other.Reserved && self.TotalSize == other.TotalSize
2981     }
2982 }
2983 impl ::std::cmp::Eq for NDR64_FIX_ARRAY_HEADER_FORMAT {}
2984 unsafe impl ::windows::runtime::Abi for NDR64_FIX_ARRAY_HEADER_FORMAT {
2985     type Abi = Self;
2986     type DefaultType = Self;
2987 }
2988 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2989 #[repr(C)]
2990 pub struct NDR64_IID_FLAGS {
2991     pub _bitfield: u8,
2992 }
2993 impl NDR64_IID_FLAGS {}
2994 impl ::std::default::Default for NDR64_IID_FLAGS {
default() -> Self2995     fn default() -> Self {
2996         unsafe { ::std::mem::zeroed() }
2997     }
2998 }
2999 impl ::std::fmt::Debug for NDR64_IID_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3000     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3001         fmt.debug_struct("NDR64_IID_FLAGS").field("_bitfield", &self._bitfield).finish()
3002     }
3003 }
3004 impl ::std::cmp::PartialEq for NDR64_IID_FLAGS {
eq(&self, other: &Self) -> bool3005     fn eq(&self, other: &Self) -> bool {
3006         self._bitfield == other._bitfield
3007     }
3008 }
3009 impl ::std::cmp::Eq for NDR64_IID_FLAGS {}
3010 unsafe impl ::windows::runtime::Abi for NDR64_IID_FLAGS {
3011     type Abi = Self;
3012     type DefaultType = Self;
3013 }
3014 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3015 #[repr(C)]
3016 pub struct NDR64_IID_FORMAT {
3017     pub FormatCode: u8,
3018     pub Flags: u8,
3019     pub Reserved: u16,
3020     pub IIDDescriptor: *mut ::std::ffi::c_void,
3021 }
3022 impl NDR64_IID_FORMAT {}
3023 impl ::std::default::Default for NDR64_IID_FORMAT {
default() -> Self3024     fn default() -> Self {
3025         unsafe { ::std::mem::zeroed() }
3026     }
3027 }
3028 impl ::std::fmt::Debug for NDR64_IID_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3029     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3030         fmt.debug_struct("NDR64_IID_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("IIDDescriptor", &self.IIDDescriptor).finish()
3031     }
3032 }
3033 impl ::std::cmp::PartialEq for NDR64_IID_FORMAT {
eq(&self, other: &Self) -> bool3034     fn eq(&self, other: &Self) -> bool {
3035         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Reserved == other.Reserved && self.IIDDescriptor == other.IIDDescriptor
3036     }
3037 }
3038 impl ::std::cmp::Eq for NDR64_IID_FORMAT {}
3039 unsafe impl ::windows::runtime::Abi for NDR64_IID_FORMAT {
3040     type Abi = Self;
3041     type DefaultType = Self;
3042 }
3043 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3044 #[repr(C)]
3045 pub struct NDR64_MEMPAD_FORMAT {
3046     pub FormatCode: u8,
3047     pub Reserve1: u8,
3048     pub MemPad: u16,
3049     pub Reserved2: u32,
3050 }
3051 impl NDR64_MEMPAD_FORMAT {}
3052 impl ::std::default::Default for NDR64_MEMPAD_FORMAT {
default() -> Self3053     fn default() -> Self {
3054         unsafe { ::std::mem::zeroed() }
3055     }
3056 }
3057 impl ::std::fmt::Debug for NDR64_MEMPAD_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3058     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3059         fmt.debug_struct("NDR64_MEMPAD_FORMAT").field("FormatCode", &self.FormatCode).field("Reserve1", &self.Reserve1).field("MemPad", &self.MemPad).field("Reserved2", &self.Reserved2).finish()
3060     }
3061 }
3062 impl ::std::cmp::PartialEq for NDR64_MEMPAD_FORMAT {
eq(&self, other: &Self) -> bool3063     fn eq(&self, other: &Self) -> bool {
3064         self.FormatCode == other.FormatCode && self.Reserve1 == other.Reserve1 && self.MemPad == other.MemPad && self.Reserved2 == other.Reserved2
3065     }
3066 }
3067 impl ::std::cmp::Eq for NDR64_MEMPAD_FORMAT {}
3068 unsafe impl ::windows::runtime::Abi for NDR64_MEMPAD_FORMAT {
3069     type Abi = Self;
3070     type DefaultType = Self;
3071 }
3072 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3073 #[repr(C)]
3074 pub struct NDR64_NON_CONFORMANT_STRING_FORMAT {
3075     pub Header: NDR64_STRING_HEADER_FORMAT,
3076     pub TotalSize: u32,
3077 }
3078 impl NDR64_NON_CONFORMANT_STRING_FORMAT {}
3079 impl ::std::default::Default for NDR64_NON_CONFORMANT_STRING_FORMAT {
default() -> Self3080     fn default() -> Self {
3081         unsafe { ::std::mem::zeroed() }
3082     }
3083 }
3084 impl ::std::fmt::Debug for NDR64_NON_CONFORMANT_STRING_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3085     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3086         fmt.debug_struct("NDR64_NON_CONFORMANT_STRING_FORMAT").field("Header", &self.Header).field("TotalSize", &self.TotalSize).finish()
3087     }
3088 }
3089 impl ::std::cmp::PartialEq for NDR64_NON_CONFORMANT_STRING_FORMAT {
eq(&self, other: &Self) -> bool3090     fn eq(&self, other: &Self) -> bool {
3091         self.Header == other.Header && self.TotalSize == other.TotalSize
3092     }
3093 }
3094 impl ::std::cmp::Eq for NDR64_NON_CONFORMANT_STRING_FORMAT {}
3095 unsafe impl ::windows::runtime::Abi for NDR64_NON_CONFORMANT_STRING_FORMAT {
3096     type Abi = Self;
3097     type DefaultType = Self;
3098 }
3099 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3100 #[repr(C)]
3101 pub struct NDR64_NON_ENCAPSULATED_UNION {
3102     pub FormatCode: u8,
3103     pub Alignment: u8,
3104     pub Flags: u8,
3105     pub SwitchType: u8,
3106     pub MemorySize: u32,
3107     pub Switch: *mut ::std::ffi::c_void,
3108     pub Reserved: u32,
3109 }
3110 impl NDR64_NON_ENCAPSULATED_UNION {}
3111 impl ::std::default::Default for NDR64_NON_ENCAPSULATED_UNION {
default() -> Self3112     fn default() -> Self {
3113         unsafe { ::std::mem::zeroed() }
3114     }
3115 }
3116 impl ::std::fmt::Debug for NDR64_NON_ENCAPSULATED_UNION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3117     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3118         fmt.debug_struct("NDR64_NON_ENCAPSULATED_UNION").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("SwitchType", &self.SwitchType).field("MemorySize", &self.MemorySize).field("Switch", &self.Switch).field("Reserved", &self.Reserved).finish()
3119     }
3120 }
3121 impl ::std::cmp::PartialEq for NDR64_NON_ENCAPSULATED_UNION {
eq(&self, other: &Self) -> bool3122     fn eq(&self, other: &Self) -> bool {
3123         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.SwitchType == other.SwitchType && self.MemorySize == other.MemorySize && self.Switch == other.Switch && self.Reserved == other.Reserved
3124     }
3125 }
3126 impl ::std::cmp::Eq for NDR64_NON_ENCAPSULATED_UNION {}
3127 unsafe impl ::windows::runtime::Abi for NDR64_NON_ENCAPSULATED_UNION {
3128     type Abi = Self;
3129     type DefaultType = Self;
3130 }
3131 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3132 #[repr(C)]
3133 pub struct NDR64_NO_REPEAT_FORMAT {
3134     pub FormatCode: u8,
3135     pub Flags: u8,
3136     pub Reserved1: u16,
3137     pub Reserved2: u32,
3138 }
3139 impl NDR64_NO_REPEAT_FORMAT {}
3140 impl ::std::default::Default for NDR64_NO_REPEAT_FORMAT {
default() -> Self3141     fn default() -> Self {
3142         unsafe { ::std::mem::zeroed() }
3143     }
3144 }
3145 impl ::std::fmt::Debug for NDR64_NO_REPEAT_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3146     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3147         fmt.debug_struct("NDR64_NO_REPEAT_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Reserved1", &self.Reserved1).field("Reserved2", &self.Reserved2).finish()
3148     }
3149 }
3150 impl ::std::cmp::PartialEq for NDR64_NO_REPEAT_FORMAT {
eq(&self, other: &Self) -> bool3151     fn eq(&self, other: &Self) -> bool {
3152         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2
3153     }
3154 }
3155 impl ::std::cmp::Eq for NDR64_NO_REPEAT_FORMAT {}
3156 unsafe impl ::windows::runtime::Abi for NDR64_NO_REPEAT_FORMAT {
3157     type Abi = Self;
3158     type DefaultType = Self;
3159 }
3160 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3161 #[repr(C)]
3162 pub struct NDR64_PARAM_FLAGS {
3163     pub _bitfield: u16,
3164 }
3165 impl NDR64_PARAM_FLAGS {}
3166 impl ::std::default::Default for NDR64_PARAM_FLAGS {
default() -> Self3167     fn default() -> Self {
3168         unsafe { ::std::mem::zeroed() }
3169     }
3170 }
3171 impl ::std::fmt::Debug for NDR64_PARAM_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3172     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3173         fmt.debug_struct("NDR64_PARAM_FLAGS").field("_bitfield", &self._bitfield).finish()
3174     }
3175 }
3176 impl ::std::cmp::PartialEq for NDR64_PARAM_FLAGS {
eq(&self, other: &Self) -> bool3177     fn eq(&self, other: &Self) -> bool {
3178         self._bitfield == other._bitfield
3179     }
3180 }
3181 impl ::std::cmp::Eq for NDR64_PARAM_FLAGS {}
3182 unsafe impl ::windows::runtime::Abi for NDR64_PARAM_FLAGS {
3183     type Abi = Self;
3184     type DefaultType = Self;
3185 }
3186 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3187 #[repr(C)]
3188 pub struct NDR64_PARAM_FORMAT {
3189     pub Type: *mut ::std::ffi::c_void,
3190     pub Attributes: NDR64_PARAM_FLAGS,
3191     pub Reserved: u16,
3192     pub StackOffset: u32,
3193 }
3194 impl NDR64_PARAM_FORMAT {}
3195 impl ::std::default::Default for NDR64_PARAM_FORMAT {
default() -> Self3196     fn default() -> Self {
3197         unsafe { ::std::mem::zeroed() }
3198     }
3199 }
3200 impl ::std::fmt::Debug for NDR64_PARAM_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3201     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3202         fmt.debug_struct("NDR64_PARAM_FORMAT").field("Type", &self.Type).field("Attributes", &self.Attributes).field("Reserved", &self.Reserved).field("StackOffset", &self.StackOffset).finish()
3203     }
3204 }
3205 impl ::std::cmp::PartialEq for NDR64_PARAM_FORMAT {
eq(&self, other: &Self) -> bool3206     fn eq(&self, other: &Self) -> bool {
3207         self.Type == other.Type && self.Attributes == other.Attributes && self.Reserved == other.Reserved && self.StackOffset == other.StackOffset
3208     }
3209 }
3210 impl ::std::cmp::Eq for NDR64_PARAM_FORMAT {}
3211 unsafe impl ::windows::runtime::Abi for NDR64_PARAM_FORMAT {
3212     type Abi = Self;
3213     type DefaultType = Self;
3214 }
3215 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3216 #[repr(C)]
3217 pub struct NDR64_PIPE_FLAGS {
3218     pub _bitfield: u8,
3219 }
3220 impl NDR64_PIPE_FLAGS {}
3221 impl ::std::default::Default for NDR64_PIPE_FLAGS {
default() -> Self3222     fn default() -> Self {
3223         unsafe { ::std::mem::zeroed() }
3224     }
3225 }
3226 impl ::std::fmt::Debug for NDR64_PIPE_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3227     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3228         fmt.debug_struct("NDR64_PIPE_FLAGS").field("_bitfield", &self._bitfield).finish()
3229     }
3230 }
3231 impl ::std::cmp::PartialEq for NDR64_PIPE_FLAGS {
eq(&self, other: &Self) -> bool3232     fn eq(&self, other: &Self) -> bool {
3233         self._bitfield == other._bitfield
3234     }
3235 }
3236 impl ::std::cmp::Eq for NDR64_PIPE_FLAGS {}
3237 unsafe impl ::windows::runtime::Abi for NDR64_PIPE_FLAGS {
3238     type Abi = Self;
3239     type DefaultType = Self;
3240 }
3241 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3242 #[repr(C)]
3243 pub struct NDR64_PIPE_FORMAT {
3244     pub FormatCode: u8,
3245     pub Flags: u8,
3246     pub Alignment: u8,
3247     pub Reserved: u8,
3248     pub Type: *mut ::std::ffi::c_void,
3249     pub MemorySize: u32,
3250     pub BufferSize: u32,
3251 }
3252 impl NDR64_PIPE_FORMAT {}
3253 impl ::std::default::Default for NDR64_PIPE_FORMAT {
default() -> Self3254     fn default() -> Self {
3255         unsafe { ::std::mem::zeroed() }
3256     }
3257 }
3258 impl ::std::fmt::Debug for NDR64_PIPE_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3259     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3260         fmt.debug_struct("NDR64_PIPE_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Alignment", &self.Alignment).field("Reserved", &self.Reserved).field("Type", &self.Type).field("MemorySize", &self.MemorySize).field("BufferSize", &self.BufferSize).finish()
3261     }
3262 }
3263 impl ::std::cmp::PartialEq for NDR64_PIPE_FORMAT {
eq(&self, other: &Self) -> bool3264     fn eq(&self, other: &Self) -> bool {
3265         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Alignment == other.Alignment && self.Reserved == other.Reserved && self.Type == other.Type && self.MemorySize == other.MemorySize && self.BufferSize == other.BufferSize
3266     }
3267 }
3268 impl ::std::cmp::Eq for NDR64_PIPE_FORMAT {}
3269 unsafe impl ::windows::runtime::Abi for NDR64_PIPE_FORMAT {
3270     type Abi = Self;
3271     type DefaultType = Self;
3272 }
3273 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3274 #[repr(C)]
3275 pub struct NDR64_POINTER_FORMAT {
3276     pub FormatCode: u8,
3277     pub Flags: u8,
3278     pub Reserved: u16,
3279     pub Pointee: *mut ::std::ffi::c_void,
3280 }
3281 impl NDR64_POINTER_FORMAT {}
3282 impl ::std::default::Default for NDR64_POINTER_FORMAT {
default() -> Self3283     fn default() -> Self {
3284         unsafe { ::std::mem::zeroed() }
3285     }
3286 }
3287 impl ::std::fmt::Debug for NDR64_POINTER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3288     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3289         fmt.debug_struct("NDR64_POINTER_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("Pointee", &self.Pointee).finish()
3290     }
3291 }
3292 impl ::std::cmp::PartialEq for NDR64_POINTER_FORMAT {
eq(&self, other: &Self) -> bool3293     fn eq(&self, other: &Self) -> bool {
3294         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Reserved == other.Reserved && self.Pointee == other.Pointee
3295     }
3296 }
3297 impl ::std::cmp::Eq for NDR64_POINTER_FORMAT {}
3298 unsafe impl ::windows::runtime::Abi for NDR64_POINTER_FORMAT {
3299     type Abi = Self;
3300     type DefaultType = Self;
3301 }
3302 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3303 #[repr(C)]
3304 pub struct NDR64_POINTER_INSTANCE_HEADER_FORMAT {
3305     pub Offset: u32,
3306     pub Reserved: u32,
3307 }
3308 impl NDR64_POINTER_INSTANCE_HEADER_FORMAT {}
3309 impl ::std::default::Default for NDR64_POINTER_INSTANCE_HEADER_FORMAT {
default() -> Self3310     fn default() -> Self {
3311         unsafe { ::std::mem::zeroed() }
3312     }
3313 }
3314 impl ::std::fmt::Debug for NDR64_POINTER_INSTANCE_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3315     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3316         fmt.debug_struct("NDR64_POINTER_INSTANCE_HEADER_FORMAT").field("Offset", &self.Offset).field("Reserved", &self.Reserved).finish()
3317     }
3318 }
3319 impl ::std::cmp::PartialEq for NDR64_POINTER_INSTANCE_HEADER_FORMAT {
eq(&self, other: &Self) -> bool3320     fn eq(&self, other: &Self) -> bool {
3321         self.Offset == other.Offset && self.Reserved == other.Reserved
3322     }
3323 }
3324 impl ::std::cmp::Eq for NDR64_POINTER_INSTANCE_HEADER_FORMAT {}
3325 unsafe impl ::windows::runtime::Abi for NDR64_POINTER_INSTANCE_HEADER_FORMAT {
3326     type Abi = Self;
3327     type DefaultType = Self;
3328 }
3329 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3330 #[repr(C)]
3331 pub struct NDR64_POINTER_REPEAT_FLAGS {
3332     pub _bitfield: u8,
3333 }
3334 impl NDR64_POINTER_REPEAT_FLAGS {}
3335 impl ::std::default::Default for NDR64_POINTER_REPEAT_FLAGS {
default() -> Self3336     fn default() -> Self {
3337         unsafe { ::std::mem::zeroed() }
3338     }
3339 }
3340 impl ::std::fmt::Debug for NDR64_POINTER_REPEAT_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3341     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3342         fmt.debug_struct("NDR64_POINTER_REPEAT_FLAGS").field("_bitfield", &self._bitfield).finish()
3343     }
3344 }
3345 impl ::std::cmp::PartialEq for NDR64_POINTER_REPEAT_FLAGS {
eq(&self, other: &Self) -> bool3346     fn eq(&self, other: &Self) -> bool {
3347         self._bitfield == other._bitfield
3348     }
3349 }
3350 impl ::std::cmp::Eq for NDR64_POINTER_REPEAT_FLAGS {}
3351 unsafe impl ::windows::runtime::Abi for NDR64_POINTER_REPEAT_FLAGS {
3352     type Abi = Self;
3353     type DefaultType = Self;
3354 }
3355 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3356 #[repr(C)]
3357 pub struct NDR64_PROC_FLAGS {
3358     pub _bitfield: u32,
3359 }
3360 impl NDR64_PROC_FLAGS {}
3361 impl ::std::default::Default for NDR64_PROC_FLAGS {
default() -> Self3362     fn default() -> Self {
3363         unsafe { ::std::mem::zeroed() }
3364     }
3365 }
3366 impl ::std::fmt::Debug for NDR64_PROC_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3367     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3368         fmt.debug_struct("NDR64_PROC_FLAGS").field("_bitfield", &self._bitfield).finish()
3369     }
3370 }
3371 impl ::std::cmp::PartialEq for NDR64_PROC_FLAGS {
eq(&self, other: &Self) -> bool3372     fn eq(&self, other: &Self) -> bool {
3373         self._bitfield == other._bitfield
3374     }
3375 }
3376 impl ::std::cmp::Eq for NDR64_PROC_FLAGS {}
3377 unsafe impl ::windows::runtime::Abi for NDR64_PROC_FLAGS {
3378     type Abi = Self;
3379     type DefaultType = Self;
3380 }
3381 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3382 #[repr(C)]
3383 pub struct NDR64_PROC_FORMAT {
3384     pub Flags: u32,
3385     pub StackSize: u32,
3386     pub ConstantClientBufferSize: u32,
3387     pub ConstantServerBufferSize: u32,
3388     pub RpcFlags: u16,
3389     pub FloatDoubleMask: u16,
3390     pub NumberOfParams: u16,
3391     pub ExtensionSize: u16,
3392 }
3393 impl NDR64_PROC_FORMAT {}
3394 impl ::std::default::Default for NDR64_PROC_FORMAT {
default() -> Self3395     fn default() -> Self {
3396         unsafe { ::std::mem::zeroed() }
3397     }
3398 }
3399 impl ::std::fmt::Debug for NDR64_PROC_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3400     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3401         fmt.debug_struct("NDR64_PROC_FORMAT")
3402             .field("Flags", &self.Flags)
3403             .field("StackSize", &self.StackSize)
3404             .field("ConstantClientBufferSize", &self.ConstantClientBufferSize)
3405             .field("ConstantServerBufferSize", &self.ConstantServerBufferSize)
3406             .field("RpcFlags", &self.RpcFlags)
3407             .field("FloatDoubleMask", &self.FloatDoubleMask)
3408             .field("NumberOfParams", &self.NumberOfParams)
3409             .field("ExtensionSize", &self.ExtensionSize)
3410             .finish()
3411     }
3412 }
3413 impl ::std::cmp::PartialEq for NDR64_PROC_FORMAT {
eq(&self, other: &Self) -> bool3414     fn eq(&self, other: &Self) -> bool {
3415         self.Flags == other.Flags && self.StackSize == other.StackSize && self.ConstantClientBufferSize == other.ConstantClientBufferSize && self.ConstantServerBufferSize == other.ConstantServerBufferSize && self.RpcFlags == other.RpcFlags && self.FloatDoubleMask == other.FloatDoubleMask && self.NumberOfParams == other.NumberOfParams && self.ExtensionSize == other.ExtensionSize
3416     }
3417 }
3418 impl ::std::cmp::Eq for NDR64_PROC_FORMAT {}
3419 unsafe impl ::windows::runtime::Abi for NDR64_PROC_FORMAT {
3420     type Abi = Self;
3421     type DefaultType = Self;
3422 }
3423 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3424 #[repr(C)]
3425 pub struct NDR64_RANGED_STRING_FORMAT {
3426     pub Header: NDR64_STRING_HEADER_FORMAT,
3427     pub Reserved: u32,
3428     pub Min: u64,
3429     pub Max: u64,
3430 }
3431 impl NDR64_RANGED_STRING_FORMAT {}
3432 impl ::std::default::Default for NDR64_RANGED_STRING_FORMAT {
default() -> Self3433     fn default() -> Self {
3434         unsafe { ::std::mem::zeroed() }
3435     }
3436 }
3437 impl ::std::fmt::Debug for NDR64_RANGED_STRING_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3438     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3439         fmt.debug_struct("NDR64_RANGED_STRING_FORMAT").field("Header", &self.Header).field("Reserved", &self.Reserved).field("Min", &self.Min).field("Max", &self.Max).finish()
3440     }
3441 }
3442 impl ::std::cmp::PartialEq for NDR64_RANGED_STRING_FORMAT {
eq(&self, other: &Self) -> bool3443     fn eq(&self, other: &Self) -> bool {
3444         self.Header == other.Header && self.Reserved == other.Reserved && self.Min == other.Min && self.Max == other.Max
3445     }
3446 }
3447 impl ::std::cmp::Eq for NDR64_RANGED_STRING_FORMAT {}
3448 unsafe impl ::windows::runtime::Abi for NDR64_RANGED_STRING_FORMAT {
3449     type Abi = Self;
3450     type DefaultType = Self;
3451 }
3452 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3453 #[repr(C)]
3454 pub struct NDR64_RANGE_FORMAT {
3455     pub FormatCode: u8,
3456     pub RangeType: u8,
3457     pub Reserved: u16,
3458     pub MinValue: i64,
3459     pub MaxValue: i64,
3460 }
3461 impl NDR64_RANGE_FORMAT {}
3462 impl ::std::default::Default for NDR64_RANGE_FORMAT {
default() -> Self3463     fn default() -> Self {
3464         unsafe { ::std::mem::zeroed() }
3465     }
3466 }
3467 impl ::std::fmt::Debug for NDR64_RANGE_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3468     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3469         fmt.debug_struct("NDR64_RANGE_FORMAT").field("FormatCode", &self.FormatCode).field("RangeType", &self.RangeType).field("Reserved", &self.Reserved).field("MinValue", &self.MinValue).field("MaxValue", &self.MaxValue).finish()
3470     }
3471 }
3472 impl ::std::cmp::PartialEq for NDR64_RANGE_FORMAT {
eq(&self, other: &Self) -> bool3473     fn eq(&self, other: &Self) -> bool {
3474         self.FormatCode == other.FormatCode && self.RangeType == other.RangeType && self.Reserved == other.Reserved && self.MinValue == other.MinValue && self.MaxValue == other.MaxValue
3475     }
3476 }
3477 impl ::std::cmp::Eq for NDR64_RANGE_FORMAT {}
3478 unsafe impl ::windows::runtime::Abi for NDR64_RANGE_FORMAT {
3479     type Abi = Self;
3480     type DefaultType = Self;
3481 }
3482 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3483 #[repr(C)]
3484 pub struct NDR64_RANGE_PIPE_FORMAT {
3485     pub FormatCode: u8,
3486     pub Flags: u8,
3487     pub Alignment: u8,
3488     pub Reserved: u8,
3489     pub Type: *mut ::std::ffi::c_void,
3490     pub MemorySize: u32,
3491     pub BufferSize: u32,
3492     pub MinValue: u32,
3493     pub MaxValue: u32,
3494 }
3495 impl NDR64_RANGE_PIPE_FORMAT {}
3496 impl ::std::default::Default for NDR64_RANGE_PIPE_FORMAT {
default() -> Self3497     fn default() -> Self {
3498         unsafe { ::std::mem::zeroed() }
3499     }
3500 }
3501 impl ::std::fmt::Debug for NDR64_RANGE_PIPE_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3502     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3503         fmt.debug_struct("NDR64_RANGE_PIPE_FORMAT")
3504             .field("FormatCode", &self.FormatCode)
3505             .field("Flags", &self.Flags)
3506             .field("Alignment", &self.Alignment)
3507             .field("Reserved", &self.Reserved)
3508             .field("Type", &self.Type)
3509             .field("MemorySize", &self.MemorySize)
3510             .field("BufferSize", &self.BufferSize)
3511             .field("MinValue", &self.MinValue)
3512             .field("MaxValue", &self.MaxValue)
3513             .finish()
3514     }
3515 }
3516 impl ::std::cmp::PartialEq for NDR64_RANGE_PIPE_FORMAT {
eq(&self, other: &Self) -> bool3517     fn eq(&self, other: &Self) -> bool {
3518         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Alignment == other.Alignment && self.Reserved == other.Reserved && self.Type == other.Type && self.MemorySize == other.MemorySize && self.BufferSize == other.BufferSize && self.MinValue == other.MinValue && self.MaxValue == other.MaxValue
3519     }
3520 }
3521 impl ::std::cmp::Eq for NDR64_RANGE_PIPE_FORMAT {}
3522 unsafe impl ::windows::runtime::Abi for NDR64_RANGE_PIPE_FORMAT {
3523     type Abi = Self;
3524     type DefaultType = Self;
3525 }
3526 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3527 #[repr(C)]
3528 pub struct NDR64_REPEAT_FORMAT {
3529     pub FormatCode: u8,
3530     pub Flags: NDR64_POINTER_REPEAT_FLAGS,
3531     pub Reserved: u16,
3532     pub Increment: u32,
3533     pub OffsetToArray: u32,
3534     pub NumberOfPointers: u32,
3535 }
3536 impl NDR64_REPEAT_FORMAT {}
3537 impl ::std::default::Default for NDR64_REPEAT_FORMAT {
default() -> Self3538     fn default() -> Self {
3539         unsafe { ::std::mem::zeroed() }
3540     }
3541 }
3542 impl ::std::fmt::Debug for NDR64_REPEAT_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3544         fmt.debug_struct("NDR64_REPEAT_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("Reserved", &self.Reserved).field("Increment", &self.Increment).field("OffsetToArray", &self.OffsetToArray).field("NumberOfPointers", &self.NumberOfPointers).finish()
3545     }
3546 }
3547 impl ::std::cmp::PartialEq for NDR64_REPEAT_FORMAT {
eq(&self, other: &Self) -> bool3548     fn eq(&self, other: &Self) -> bool {
3549         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.Reserved == other.Reserved && self.Increment == other.Increment && self.OffsetToArray == other.OffsetToArray && self.NumberOfPointers == other.NumberOfPointers
3550     }
3551 }
3552 impl ::std::cmp::Eq for NDR64_REPEAT_FORMAT {}
3553 unsafe impl ::windows::runtime::Abi for NDR64_REPEAT_FORMAT {
3554     type Abi = Self;
3555     type DefaultType = Self;
3556 }
3557 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3558 #[repr(C)]
3559 pub struct NDR64_RPC_FLAGS {
3560     pub _bitfield: u16,
3561 }
3562 impl NDR64_RPC_FLAGS {}
3563 impl ::std::default::Default for NDR64_RPC_FLAGS {
default() -> Self3564     fn default() -> Self {
3565         unsafe { ::std::mem::zeroed() }
3566     }
3567 }
3568 impl ::std::fmt::Debug for NDR64_RPC_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3569     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3570         fmt.debug_struct("NDR64_RPC_FLAGS").field("_bitfield", &self._bitfield).finish()
3571     }
3572 }
3573 impl ::std::cmp::PartialEq for NDR64_RPC_FLAGS {
eq(&self, other: &Self) -> bool3574     fn eq(&self, other: &Self) -> bool {
3575         self._bitfield == other._bitfield
3576     }
3577 }
3578 impl ::std::cmp::Eq for NDR64_RPC_FLAGS {}
3579 unsafe impl ::windows::runtime::Abi for NDR64_RPC_FLAGS {
3580     type Abi = Self;
3581     type DefaultType = Self;
3582 }
3583 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3584 #[repr(C)]
3585 pub struct NDR64_SIMPLE_MEMBER_FORMAT {
3586     pub FormatCode: u8,
3587     pub Reserved1: u8,
3588     pub Reserved2: u16,
3589     pub Reserved3: u32,
3590 }
3591 impl NDR64_SIMPLE_MEMBER_FORMAT {}
3592 impl ::std::default::Default for NDR64_SIMPLE_MEMBER_FORMAT {
default() -> Self3593     fn default() -> Self {
3594         unsafe { ::std::mem::zeroed() }
3595     }
3596 }
3597 impl ::std::fmt::Debug for NDR64_SIMPLE_MEMBER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3598     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3599         fmt.debug_struct("NDR64_SIMPLE_MEMBER_FORMAT").field("FormatCode", &self.FormatCode).field("Reserved1", &self.Reserved1).field("Reserved2", &self.Reserved2).field("Reserved3", &self.Reserved3).finish()
3600     }
3601 }
3602 impl ::std::cmp::PartialEq for NDR64_SIMPLE_MEMBER_FORMAT {
eq(&self, other: &Self) -> bool3603     fn eq(&self, other: &Self) -> bool {
3604         self.FormatCode == other.FormatCode && self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2 && self.Reserved3 == other.Reserved3
3605     }
3606 }
3607 impl ::std::cmp::Eq for NDR64_SIMPLE_MEMBER_FORMAT {}
3608 unsafe impl ::windows::runtime::Abi for NDR64_SIMPLE_MEMBER_FORMAT {
3609     type Abi = Self;
3610     type DefaultType = Self;
3611 }
3612 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3613 #[repr(C)]
3614 pub struct NDR64_SIMPLE_REGION_FORMAT {
3615     pub FormatCode: u8,
3616     pub Alignment: u8,
3617     pub RegionSize: u16,
3618     pub Reserved: u32,
3619 }
3620 impl NDR64_SIMPLE_REGION_FORMAT {}
3621 impl ::std::default::Default for NDR64_SIMPLE_REGION_FORMAT {
default() -> Self3622     fn default() -> Self {
3623         unsafe { ::std::mem::zeroed() }
3624     }
3625 }
3626 impl ::std::fmt::Debug for NDR64_SIMPLE_REGION_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3627     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3628         fmt.debug_struct("NDR64_SIMPLE_REGION_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("RegionSize", &self.RegionSize).field("Reserved", &self.Reserved).finish()
3629     }
3630 }
3631 impl ::std::cmp::PartialEq for NDR64_SIMPLE_REGION_FORMAT {
eq(&self, other: &Self) -> bool3632     fn eq(&self, other: &Self) -> bool {
3633         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.RegionSize == other.RegionSize && self.Reserved == other.Reserved
3634     }
3635 }
3636 impl ::std::cmp::Eq for NDR64_SIMPLE_REGION_FORMAT {}
3637 unsafe impl ::windows::runtime::Abi for NDR64_SIMPLE_REGION_FORMAT {
3638     type Abi = Self;
3639     type DefaultType = Self;
3640 }
3641 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3642 #[repr(C)]
3643 pub struct NDR64_SIZED_CONFORMANT_STRING_FORMAT {
3644     pub Header: NDR64_STRING_HEADER_FORMAT,
3645     pub SizeDescription: *mut ::std::ffi::c_void,
3646 }
3647 impl NDR64_SIZED_CONFORMANT_STRING_FORMAT {}
3648 impl ::std::default::Default for NDR64_SIZED_CONFORMANT_STRING_FORMAT {
default() -> Self3649     fn default() -> Self {
3650         unsafe { ::std::mem::zeroed() }
3651     }
3652 }
3653 impl ::std::fmt::Debug for NDR64_SIZED_CONFORMANT_STRING_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3654     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3655         fmt.debug_struct("NDR64_SIZED_CONFORMANT_STRING_FORMAT").field("Header", &self.Header).field("SizeDescription", &self.SizeDescription).finish()
3656     }
3657 }
3658 impl ::std::cmp::PartialEq for NDR64_SIZED_CONFORMANT_STRING_FORMAT {
eq(&self, other: &Self) -> bool3659     fn eq(&self, other: &Self) -> bool {
3660         self.Header == other.Header && self.SizeDescription == other.SizeDescription
3661     }
3662 }
3663 impl ::std::cmp::Eq for NDR64_SIZED_CONFORMANT_STRING_FORMAT {}
3664 unsafe impl ::windows::runtime::Abi for NDR64_SIZED_CONFORMANT_STRING_FORMAT {
3665     type Abi = Self;
3666     type DefaultType = Self;
3667 }
3668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3669 #[repr(C)]
3670 pub struct NDR64_STRING_FLAGS {
3671     pub _bitfield: u8,
3672 }
3673 impl NDR64_STRING_FLAGS {}
3674 impl ::std::default::Default for NDR64_STRING_FLAGS {
default() -> Self3675     fn default() -> Self {
3676         unsafe { ::std::mem::zeroed() }
3677     }
3678 }
3679 impl ::std::fmt::Debug for NDR64_STRING_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3680     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3681         fmt.debug_struct("NDR64_STRING_FLAGS").field("_bitfield", &self._bitfield).finish()
3682     }
3683 }
3684 impl ::std::cmp::PartialEq for NDR64_STRING_FLAGS {
eq(&self, other: &Self) -> bool3685     fn eq(&self, other: &Self) -> bool {
3686         self._bitfield == other._bitfield
3687     }
3688 }
3689 impl ::std::cmp::Eq for NDR64_STRING_FLAGS {}
3690 unsafe impl ::windows::runtime::Abi for NDR64_STRING_FLAGS {
3691     type Abi = Self;
3692     type DefaultType = Self;
3693 }
3694 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3695 #[repr(C)]
3696 pub struct NDR64_STRING_HEADER_FORMAT {
3697     pub FormatCode: u8,
3698     pub Flags: NDR64_STRING_FLAGS,
3699     pub ElementSize: u16,
3700 }
3701 impl NDR64_STRING_HEADER_FORMAT {}
3702 impl ::std::default::Default for NDR64_STRING_HEADER_FORMAT {
default() -> Self3703     fn default() -> Self {
3704         unsafe { ::std::mem::zeroed() }
3705     }
3706 }
3707 impl ::std::fmt::Debug for NDR64_STRING_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3708     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3709         fmt.debug_struct("NDR64_STRING_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Flags", &self.Flags).field("ElementSize", &self.ElementSize).finish()
3710     }
3711 }
3712 impl ::std::cmp::PartialEq for NDR64_STRING_HEADER_FORMAT {
eq(&self, other: &Self) -> bool3713     fn eq(&self, other: &Self) -> bool {
3714         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.ElementSize == other.ElementSize
3715     }
3716 }
3717 impl ::std::cmp::Eq for NDR64_STRING_HEADER_FORMAT {}
3718 unsafe impl ::windows::runtime::Abi for NDR64_STRING_HEADER_FORMAT {
3719     type Abi = Self;
3720     type DefaultType = Self;
3721 }
3722 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3723 #[repr(C)]
3724 pub struct NDR64_STRUCTURE_FLAGS {
3725     pub _bitfield: u8,
3726 }
3727 impl NDR64_STRUCTURE_FLAGS {}
3728 impl ::std::default::Default for NDR64_STRUCTURE_FLAGS {
default() -> Self3729     fn default() -> Self {
3730         unsafe { ::std::mem::zeroed() }
3731     }
3732 }
3733 impl ::std::fmt::Debug for NDR64_STRUCTURE_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3734     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3735         fmt.debug_struct("NDR64_STRUCTURE_FLAGS").field("_bitfield", &self._bitfield).finish()
3736     }
3737 }
3738 impl ::std::cmp::PartialEq for NDR64_STRUCTURE_FLAGS {
eq(&self, other: &Self) -> bool3739     fn eq(&self, other: &Self) -> bool {
3740         self._bitfield == other._bitfield
3741     }
3742 }
3743 impl ::std::cmp::Eq for NDR64_STRUCTURE_FLAGS {}
3744 unsafe impl ::windows::runtime::Abi for NDR64_STRUCTURE_FLAGS {
3745     type Abi = Self;
3746     type DefaultType = Self;
3747 }
3748 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3749 #[repr(C)]
3750 pub struct NDR64_STRUCTURE_HEADER_FORMAT {
3751     pub FormatCode: u8,
3752     pub Alignment: u8,
3753     pub Flags: NDR64_STRUCTURE_FLAGS,
3754     pub Reserve: u8,
3755     pub MemorySize: u32,
3756 }
3757 impl NDR64_STRUCTURE_HEADER_FORMAT {}
3758 impl ::std::default::Default for NDR64_STRUCTURE_HEADER_FORMAT {
default() -> Self3759     fn default() -> Self {
3760         unsafe { ::std::mem::zeroed() }
3761     }
3762 }
3763 impl ::std::fmt::Debug for NDR64_STRUCTURE_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3764     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3765         fmt.debug_struct("NDR64_STRUCTURE_HEADER_FORMAT").field("FormatCode", &self.FormatCode).field("Alignment", &self.Alignment).field("Flags", &self.Flags).field("Reserve", &self.Reserve).field("MemorySize", &self.MemorySize).finish()
3766     }
3767 }
3768 impl ::std::cmp::PartialEq for NDR64_STRUCTURE_HEADER_FORMAT {
eq(&self, other: &Self) -> bool3769     fn eq(&self, other: &Self) -> bool {
3770         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserve == other.Reserve && self.MemorySize == other.MemorySize
3771     }
3772 }
3773 impl ::std::cmp::Eq for NDR64_STRUCTURE_HEADER_FORMAT {}
3774 unsafe impl ::windows::runtime::Abi for NDR64_STRUCTURE_HEADER_FORMAT {
3775     type Abi = Self;
3776     type DefaultType = Self;
3777 }
3778 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3779 #[repr(C)]
3780 pub struct NDR64_SYSTEM_HANDLE_FORMAT {
3781     pub FormatCode: u8,
3782     pub HandleType: u8,
3783     pub DesiredAccess: u32,
3784 }
3785 impl NDR64_SYSTEM_HANDLE_FORMAT {}
3786 impl ::std::default::Default for NDR64_SYSTEM_HANDLE_FORMAT {
default() -> Self3787     fn default() -> Self {
3788         unsafe { ::std::mem::zeroed() }
3789     }
3790 }
3791 impl ::std::fmt::Debug for NDR64_SYSTEM_HANDLE_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3792     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3793         fmt.debug_struct("NDR64_SYSTEM_HANDLE_FORMAT").field("FormatCode", &self.FormatCode).field("HandleType", &self.HandleType).field("DesiredAccess", &self.DesiredAccess).finish()
3794     }
3795 }
3796 impl ::std::cmp::PartialEq for NDR64_SYSTEM_HANDLE_FORMAT {
eq(&self, other: &Self) -> bool3797     fn eq(&self, other: &Self) -> bool {
3798         self.FormatCode == other.FormatCode && self.HandleType == other.HandleType && self.DesiredAccess == other.DesiredAccess
3799     }
3800 }
3801 impl ::std::cmp::Eq for NDR64_SYSTEM_HANDLE_FORMAT {}
3802 unsafe impl ::windows::runtime::Abi for NDR64_SYSTEM_HANDLE_FORMAT {
3803     type Abi = Self;
3804     type DefaultType = Self;
3805 }
3806 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3807 #[repr(C)]
3808 pub struct NDR64_TRANSMIT_AS_FLAGS {
3809     pub _bitfield: u8,
3810 }
3811 impl NDR64_TRANSMIT_AS_FLAGS {}
3812 impl ::std::default::Default for NDR64_TRANSMIT_AS_FLAGS {
default() -> Self3813     fn default() -> Self {
3814         unsafe { ::std::mem::zeroed() }
3815     }
3816 }
3817 impl ::std::fmt::Debug for NDR64_TRANSMIT_AS_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3818     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3819         fmt.debug_struct("NDR64_TRANSMIT_AS_FLAGS").field("_bitfield", &self._bitfield).finish()
3820     }
3821 }
3822 impl ::std::cmp::PartialEq for NDR64_TRANSMIT_AS_FLAGS {
eq(&self, other: &Self) -> bool3823     fn eq(&self, other: &Self) -> bool {
3824         self._bitfield == other._bitfield
3825     }
3826 }
3827 impl ::std::cmp::Eq for NDR64_TRANSMIT_AS_FLAGS {}
3828 unsafe impl ::windows::runtime::Abi for NDR64_TRANSMIT_AS_FLAGS {
3829     type Abi = Self;
3830     type DefaultType = Self;
3831 }
3832 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3833 #[repr(C)]
3834 pub struct NDR64_TRANSMIT_AS_FORMAT {
3835     pub FormatCode: u8,
3836     pub Flags: u8,
3837     pub RoutineIndex: u16,
3838     pub TransmittedTypeWireAlignment: u16,
3839     pub MemoryAlignment: u16,
3840     pub PresentedTypeMemorySize: u32,
3841     pub TransmittedTypeBufferSize: u32,
3842     pub TransmittedType: *mut ::std::ffi::c_void,
3843 }
3844 impl NDR64_TRANSMIT_AS_FORMAT {}
3845 impl ::std::default::Default for NDR64_TRANSMIT_AS_FORMAT {
default() -> Self3846     fn default() -> Self {
3847         unsafe { ::std::mem::zeroed() }
3848     }
3849 }
3850 impl ::std::fmt::Debug for NDR64_TRANSMIT_AS_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3851     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3852         fmt.debug_struct("NDR64_TRANSMIT_AS_FORMAT")
3853             .field("FormatCode", &self.FormatCode)
3854             .field("Flags", &self.Flags)
3855             .field("RoutineIndex", &self.RoutineIndex)
3856             .field("TransmittedTypeWireAlignment", &self.TransmittedTypeWireAlignment)
3857             .field("MemoryAlignment", &self.MemoryAlignment)
3858             .field("PresentedTypeMemorySize", &self.PresentedTypeMemorySize)
3859             .field("TransmittedTypeBufferSize", &self.TransmittedTypeBufferSize)
3860             .field("TransmittedType", &self.TransmittedType)
3861             .finish()
3862     }
3863 }
3864 impl ::std::cmp::PartialEq for NDR64_TRANSMIT_AS_FORMAT {
eq(&self, other: &Self) -> bool3865     fn eq(&self, other: &Self) -> bool {
3866         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.RoutineIndex == other.RoutineIndex && self.TransmittedTypeWireAlignment == other.TransmittedTypeWireAlignment && self.MemoryAlignment == other.MemoryAlignment && self.PresentedTypeMemorySize == other.PresentedTypeMemorySize && self.TransmittedTypeBufferSize == other.TransmittedTypeBufferSize && self.TransmittedType == other.TransmittedType
3867     }
3868 }
3869 impl ::std::cmp::Eq for NDR64_TRANSMIT_AS_FORMAT {}
3870 unsafe impl ::windows::runtime::Abi for NDR64_TRANSMIT_AS_FORMAT {
3871     type Abi = Self;
3872     type DefaultType = Self;
3873 }
3874 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3875 #[repr(C)]
3876 pub struct NDR64_TYPE_STRICT_CONTEXT_HANDLE {
3877     pub FormatCode: u8,
3878     pub RealFormatCode: u8,
3879     pub Reserved: u16,
3880     pub Type: *mut ::std::ffi::c_void,
3881     pub CtxtFlags: u32,
3882     pub CtxtID: u32,
3883 }
3884 impl NDR64_TYPE_STRICT_CONTEXT_HANDLE {}
3885 impl ::std::default::Default for NDR64_TYPE_STRICT_CONTEXT_HANDLE {
default() -> Self3886     fn default() -> Self {
3887         unsafe { ::std::mem::zeroed() }
3888     }
3889 }
3890 impl ::std::fmt::Debug for NDR64_TYPE_STRICT_CONTEXT_HANDLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3891     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3892         fmt.debug_struct("NDR64_TYPE_STRICT_CONTEXT_HANDLE").field("FormatCode", &self.FormatCode).field("RealFormatCode", &self.RealFormatCode).field("Reserved", &self.Reserved).field("Type", &self.Type).field("CtxtFlags", &self.CtxtFlags).field("CtxtID", &self.CtxtID).finish()
3893     }
3894 }
3895 impl ::std::cmp::PartialEq for NDR64_TYPE_STRICT_CONTEXT_HANDLE {
eq(&self, other: &Self) -> bool3896     fn eq(&self, other: &Self) -> bool {
3897         self.FormatCode == other.FormatCode && self.RealFormatCode == other.RealFormatCode && self.Reserved == other.Reserved && self.Type == other.Type && self.CtxtFlags == other.CtxtFlags && self.CtxtID == other.CtxtID
3898     }
3899 }
3900 impl ::std::cmp::Eq for NDR64_TYPE_STRICT_CONTEXT_HANDLE {}
3901 unsafe impl ::windows::runtime::Abi for NDR64_TYPE_STRICT_CONTEXT_HANDLE {
3902     type Abi = Self;
3903     type DefaultType = Self;
3904 }
3905 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3906 #[repr(C)]
3907 pub struct NDR64_UNION_ARM {
3908     pub CaseValue: i64,
3909     pub Type: *mut ::std::ffi::c_void,
3910     pub Reserved: u32,
3911 }
3912 impl NDR64_UNION_ARM {}
3913 impl ::std::default::Default for NDR64_UNION_ARM {
default() -> Self3914     fn default() -> Self {
3915         unsafe { ::std::mem::zeroed() }
3916     }
3917 }
3918 impl ::std::fmt::Debug for NDR64_UNION_ARM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3919     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3920         fmt.debug_struct("NDR64_UNION_ARM").field("CaseValue", &self.CaseValue).field("Type", &self.Type).field("Reserved", &self.Reserved).finish()
3921     }
3922 }
3923 impl ::std::cmp::PartialEq for NDR64_UNION_ARM {
eq(&self, other: &Self) -> bool3924     fn eq(&self, other: &Self) -> bool {
3925         self.CaseValue == other.CaseValue && self.Type == other.Type && self.Reserved == other.Reserved
3926     }
3927 }
3928 impl ::std::cmp::Eq for NDR64_UNION_ARM {}
3929 unsafe impl ::windows::runtime::Abi for NDR64_UNION_ARM {
3930     type Abi = Self;
3931     type DefaultType = Self;
3932 }
3933 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3934 #[repr(C)]
3935 pub struct NDR64_UNION_ARM_SELECTOR {
3936     pub Reserved1: u8,
3937     pub Alignment: u8,
3938     pub Reserved2: u16,
3939     pub Arms: u32,
3940 }
3941 impl NDR64_UNION_ARM_SELECTOR {}
3942 impl ::std::default::Default for NDR64_UNION_ARM_SELECTOR {
default() -> Self3943     fn default() -> Self {
3944         unsafe { ::std::mem::zeroed() }
3945     }
3946 }
3947 impl ::std::fmt::Debug for NDR64_UNION_ARM_SELECTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3948     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3949         fmt.debug_struct("NDR64_UNION_ARM_SELECTOR").field("Reserved1", &self.Reserved1).field("Alignment", &self.Alignment).field("Reserved2", &self.Reserved2).field("Arms", &self.Arms).finish()
3950     }
3951 }
3952 impl ::std::cmp::PartialEq for NDR64_UNION_ARM_SELECTOR {
eq(&self, other: &Self) -> bool3953     fn eq(&self, other: &Self) -> bool {
3954         self.Reserved1 == other.Reserved1 && self.Alignment == other.Alignment && self.Reserved2 == other.Reserved2 && self.Arms == other.Arms
3955     }
3956 }
3957 impl ::std::cmp::Eq for NDR64_UNION_ARM_SELECTOR {}
3958 unsafe impl ::windows::runtime::Abi for NDR64_UNION_ARM_SELECTOR {
3959     type Abi = Self;
3960     type DefaultType = Self;
3961 }
3962 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3963 #[repr(C)]
3964 pub struct NDR64_USER_MARSHAL_FLAGS {
3965     pub _bitfield: u8,
3966 }
3967 impl NDR64_USER_MARSHAL_FLAGS {}
3968 impl ::std::default::Default for NDR64_USER_MARSHAL_FLAGS {
default() -> Self3969     fn default() -> Self {
3970         unsafe { ::std::mem::zeroed() }
3971     }
3972 }
3973 impl ::std::fmt::Debug for NDR64_USER_MARSHAL_FLAGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3974     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3975         fmt.debug_struct("NDR64_USER_MARSHAL_FLAGS").field("_bitfield", &self._bitfield).finish()
3976     }
3977 }
3978 impl ::std::cmp::PartialEq for NDR64_USER_MARSHAL_FLAGS {
eq(&self, other: &Self) -> bool3979     fn eq(&self, other: &Self) -> bool {
3980         self._bitfield == other._bitfield
3981     }
3982 }
3983 impl ::std::cmp::Eq for NDR64_USER_MARSHAL_FLAGS {}
3984 unsafe impl ::windows::runtime::Abi for NDR64_USER_MARSHAL_FLAGS {
3985     type Abi = Self;
3986     type DefaultType = Self;
3987 }
3988 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3989 #[repr(C)]
3990 pub struct NDR64_USER_MARSHAL_FORMAT {
3991     pub FormatCode: u8,
3992     pub Flags: u8,
3993     pub RoutineIndex: u16,
3994     pub TransmittedTypeWireAlignment: u16,
3995     pub MemoryAlignment: u16,
3996     pub UserTypeMemorySize: u32,
3997     pub TransmittedTypeBufferSize: u32,
3998     pub TransmittedType: *mut ::std::ffi::c_void,
3999 }
4000 impl NDR64_USER_MARSHAL_FORMAT {}
4001 impl ::std::default::Default for NDR64_USER_MARSHAL_FORMAT {
default() -> Self4002     fn default() -> Self {
4003         unsafe { ::std::mem::zeroed() }
4004     }
4005 }
4006 impl ::std::fmt::Debug for NDR64_USER_MARSHAL_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4007     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4008         fmt.debug_struct("NDR64_USER_MARSHAL_FORMAT")
4009             .field("FormatCode", &self.FormatCode)
4010             .field("Flags", &self.Flags)
4011             .field("RoutineIndex", &self.RoutineIndex)
4012             .field("TransmittedTypeWireAlignment", &self.TransmittedTypeWireAlignment)
4013             .field("MemoryAlignment", &self.MemoryAlignment)
4014             .field("UserTypeMemorySize", &self.UserTypeMemorySize)
4015             .field("TransmittedTypeBufferSize", &self.TransmittedTypeBufferSize)
4016             .field("TransmittedType", &self.TransmittedType)
4017             .finish()
4018     }
4019 }
4020 impl ::std::cmp::PartialEq for NDR64_USER_MARSHAL_FORMAT {
eq(&self, other: &Self) -> bool4021     fn eq(&self, other: &Self) -> bool {
4022         self.FormatCode == other.FormatCode && self.Flags == other.Flags && self.RoutineIndex == other.RoutineIndex && self.TransmittedTypeWireAlignment == other.TransmittedTypeWireAlignment && self.MemoryAlignment == other.MemoryAlignment && self.UserTypeMemorySize == other.UserTypeMemorySize && self.TransmittedTypeBufferSize == other.TransmittedTypeBufferSize && self.TransmittedType == other.TransmittedType
4023     }
4024 }
4025 impl ::std::cmp::Eq for NDR64_USER_MARSHAL_FORMAT {}
4026 unsafe impl ::windows::runtime::Abi for NDR64_USER_MARSHAL_FORMAT {
4027     type Abi = Self;
4028     type DefaultType = Self;
4029 }
4030 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4031 #[repr(C)]
4032 pub struct NDR64_VAR_ARRAY_HEADER_FORMAT {
4033     pub FormatCode: u8,
4034     pub Alignment: u8,
4035     pub Flags: NDR64_ARRAY_FLAGS,
4036     pub Reserved: u8,
4037     pub TotalSize: u32,
4038     pub ElementSize: u32,
4039     pub VarDescriptor: *mut ::std::ffi::c_void,
4040 }
4041 impl NDR64_VAR_ARRAY_HEADER_FORMAT {}
4042 impl ::std::default::Default for NDR64_VAR_ARRAY_HEADER_FORMAT {
default() -> Self4043     fn default() -> Self {
4044         unsafe { ::std::mem::zeroed() }
4045     }
4046 }
4047 impl ::std::fmt::Debug for NDR64_VAR_ARRAY_HEADER_FORMAT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4048     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4049         fmt.debug_struct("NDR64_VAR_ARRAY_HEADER_FORMAT")
4050             .field("FormatCode", &self.FormatCode)
4051             .field("Alignment", &self.Alignment)
4052             .field("Flags", &self.Flags)
4053             .field("Reserved", &self.Reserved)
4054             .field("TotalSize", &self.TotalSize)
4055             .field("ElementSize", &self.ElementSize)
4056             .field("VarDescriptor", &self.VarDescriptor)
4057             .finish()
4058     }
4059 }
4060 impl ::std::cmp::PartialEq for NDR64_VAR_ARRAY_HEADER_FORMAT {
eq(&self, other: &Self) -> bool4061     fn eq(&self, other: &Self) -> bool {
4062         self.FormatCode == other.FormatCode && self.Alignment == other.Alignment && self.Flags == other.Flags && self.Reserved == other.Reserved && self.TotalSize == other.TotalSize && self.ElementSize == other.ElementSize && self.VarDescriptor == other.VarDescriptor
4063     }
4064 }
4065 impl ::std::cmp::Eq for NDR64_VAR_ARRAY_HEADER_FORMAT {}
4066 unsafe impl ::windows::runtime::Abi for NDR64_VAR_ARRAY_HEADER_FORMAT {
4067     type Abi = Self;
4068     type DefaultType = Self;
4069 }
4070 #[inline]
NDRCContextBinding(ccontext: isize) -> *mut ::std::ffi::c_void4071 pub unsafe fn NDRCContextBinding(ccontext: isize) -> *mut ::std::ffi::c_void {
4072     #[cfg(windows)]
4073     {
4074         #[link(name = "windows")]
4075         extern "system" {
4076             fn NDRCContextBinding(ccontext: isize) -> *mut ::std::ffi::c_void;
4077         }
4078         ::std::mem::transmute(NDRCContextBinding(::std::mem::transmute(ccontext)))
4079     }
4080     #[cfg(not(windows))]
4081     unimplemented!("Unsupported target OS");
4082 }
4083 #[inline]
NDRCContextMarshall(ccontext: isize, pbuff: *mut ::std::ffi::c_void)4084 pub unsafe fn NDRCContextMarshall(ccontext: isize, pbuff: *mut ::std::ffi::c_void) {
4085     #[cfg(windows)]
4086     {
4087         #[link(name = "windows")]
4088         extern "system" {
4089             fn NDRCContextMarshall(ccontext: isize, pbuff: *mut ::std::ffi::c_void);
4090         }
4091         ::std::mem::transmute(NDRCContextMarshall(::std::mem::transmute(ccontext), ::std::mem::transmute(pbuff)))
4092     }
4093     #[cfg(not(windows))]
4094     unimplemented!("Unsupported target OS");
4095 }
4096 #[inline]
NDRCContextUnmarshall(pccontext: *mut isize, hbinding: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32)4097 pub unsafe fn NDRCContextUnmarshall(pccontext: *mut isize, hbinding: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32) {
4098     #[cfg(windows)]
4099     {
4100         #[link(name = "windows")]
4101         extern "system" {
4102             fn NDRCContextUnmarshall(pccontext: *mut isize, hbinding: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32);
4103         }
4104         ::std::mem::transmute(NDRCContextUnmarshall(::std::mem::transmute(pccontext), ::std::mem::transmute(hbinding), ::std::mem::transmute(pbuff), ::std::mem::transmute(datarepresentation)))
4105     }
4106     #[cfg(not(windows))]
4107     unimplemented!("Unsupported target OS");
4108 }
4109 #[inline]
NDRSContextMarshall(ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>)4110 pub unsafe fn NDRSContextMarshall(ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>) {
4111     #[cfg(windows)]
4112     {
4113         #[link(name = "windows")]
4114         extern "system" {
4115             fn NDRSContextMarshall(ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::windows::runtime::RawPtr);
4116         }
4117         ::std::mem::transmute(NDRSContextMarshall(::std::mem::transmute(ccontext), ::std::mem::transmute(pbuff), ::std::mem::transmute(userrundownin)))
4118     }
4119     #[cfg(not(windows))]
4120     unimplemented!("Unsupported target OS");
4121 }
4122 #[inline]
NDRSContextMarshall2(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>, ctxguard: *const ::std::ffi::c_void, flags: u32)4123 pub unsafe fn NDRSContextMarshall2(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>, ctxguard: *const ::std::ffi::c_void, flags: u32) {
4124     #[cfg(windows)]
4125     {
4126         #[link(name = "windows")]
4127         extern "system" {
4128             fn NDRSContextMarshall2(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::windows::runtime::RawPtr, ctxguard: *const ::std::ffi::c_void, flags: u32);
4129         }
4130         ::std::mem::transmute(NDRSContextMarshall2(::std::mem::transmute(bindinghandle), ::std::mem::transmute(ccontext), ::std::mem::transmute(pbuff), ::std::mem::transmute(userrundownin), ::std::mem::transmute(ctxguard), ::std::mem::transmute(flags)))
4131     }
4132     #[cfg(not(windows))]
4133     unimplemented!("Unsupported target OS");
4134 }
4135 #[inline]
NDRSContextMarshallEx(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>)4136 pub unsafe fn NDRSContextMarshallEx(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::std::option::Option<NDR_RUNDOWN>) {
4137     #[cfg(windows)]
4138     {
4139         #[link(name = "windows")]
4140         extern "system" {
4141             fn NDRSContextMarshallEx(bindinghandle: *const ::std::ffi::c_void, ccontext: *const NDR_SCONTEXT_1, pbuff: *mut ::std::ffi::c_void, userrundownin: ::windows::runtime::RawPtr);
4142         }
4143         ::std::mem::transmute(NDRSContextMarshallEx(::std::mem::transmute(bindinghandle), ::std::mem::transmute(ccontext), ::std::mem::transmute(pbuff), ::std::mem::transmute(userrundownin)))
4144     }
4145     #[cfg(not(windows))]
4146     unimplemented!("Unsupported target OS");
4147 }
4148 #[inline]
NDRSContextUnmarshall(pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_14149 pub unsafe fn NDRSContextUnmarshall(pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_1 {
4150     #[cfg(windows)]
4151     {
4152         #[link(name = "windows")]
4153         extern "system" {
4154             fn NDRSContextUnmarshall(pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_1;
4155         }
4156         ::std::mem::transmute(NDRSContextUnmarshall(::std::mem::transmute(pbuff), ::std::mem::transmute(datarepresentation)))
4157     }
4158     #[cfg(not(windows))]
4159     unimplemented!("Unsupported target OS");
4160 }
4161 #[inline]
NDRSContextUnmarshall2(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32, ctxguard: *const ::std::ffi::c_void, flags: u32) -> *mut NDR_SCONTEXT_14162 pub unsafe fn NDRSContextUnmarshall2(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32, ctxguard: *const ::std::ffi::c_void, flags: u32) -> *mut NDR_SCONTEXT_1 {
4163     #[cfg(windows)]
4164     {
4165         #[link(name = "windows")]
4166         extern "system" {
4167             fn NDRSContextUnmarshall2(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32, ctxguard: *const ::std::ffi::c_void, flags: u32) -> *mut NDR_SCONTEXT_1;
4168         }
4169         ::std::mem::transmute(NDRSContextUnmarshall2(::std::mem::transmute(bindinghandle), ::std::mem::transmute(pbuff), ::std::mem::transmute(datarepresentation), ::std::mem::transmute(ctxguard), ::std::mem::transmute(flags)))
4170     }
4171     #[cfg(not(windows))]
4172     unimplemented!("Unsupported target OS");
4173 }
4174 #[inline]
NDRSContextUnmarshallEx(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_14175 pub unsafe fn NDRSContextUnmarshallEx(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_1 {
4176     #[cfg(windows)]
4177     {
4178         #[link(name = "windows")]
4179         extern "system" {
4180             fn NDRSContextUnmarshallEx(bindinghandle: *const ::std::ffi::c_void, pbuff: *const ::std::ffi::c_void, datarepresentation: u32) -> *mut NDR_SCONTEXT_1;
4181         }
4182         ::std::mem::transmute(NDRSContextUnmarshallEx(::std::mem::transmute(bindinghandle), ::std::mem::transmute(pbuff), ::std::mem::transmute(datarepresentation)))
4183     }
4184     #[cfg(not(windows))]
4185     unimplemented!("Unsupported target OS");
4186 }
4187 #[repr(C)]
4188 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
4189 pub struct NDR_ALLOC_ALL_NODES_CONTEXT(pub u8);
4190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4191 #[repr(C)]
4192 pub struct NDR_CS_ROUTINES {
4193     pub pSizeConvertRoutines: *mut NDR_CS_SIZE_CONVERT_ROUTINES,
4194     pub pTagGettingRoutines: *mut ::std::option::Option<CS_TAG_GETTING_ROUTINE>,
4195 }
4196 impl NDR_CS_ROUTINES {}
4197 impl ::std::default::Default for NDR_CS_ROUTINES {
default() -> Self4198     fn default() -> Self {
4199         unsafe { ::std::mem::zeroed() }
4200     }
4201 }
4202 impl ::std::fmt::Debug for NDR_CS_ROUTINES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4203     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4204         fmt.debug_struct("NDR_CS_ROUTINES").field("pSizeConvertRoutines", &self.pSizeConvertRoutines).finish()
4205     }
4206 }
4207 impl ::std::cmp::PartialEq for NDR_CS_ROUTINES {
eq(&self, other: &Self) -> bool4208     fn eq(&self, other: &Self) -> bool {
4209         self.pSizeConvertRoutines == other.pSizeConvertRoutines && self.pTagGettingRoutines == other.pTagGettingRoutines
4210     }
4211 }
4212 impl ::std::cmp::Eq for NDR_CS_ROUTINES {}
4213 unsafe impl ::windows::runtime::Abi for NDR_CS_ROUTINES {
4214     type Abi = Self;
4215     type DefaultType = Self;
4216 }
4217 #[derive(:: std :: clone :: Clone)]
4218 #[repr(C)]
4219 pub struct NDR_CS_SIZE_CONVERT_ROUTINES {
4220     pub pfnNetSize: ::std::option::Option<CS_TYPE_NET_SIZE_ROUTINE>,
4221     pub pfnToNetCs: ::std::option::Option<CS_TYPE_TO_NETCS_ROUTINE>,
4222     pub pfnLocalSize: ::std::option::Option<CS_TYPE_LOCAL_SIZE_ROUTINE>,
4223     pub pfnFromNetCs: ::std::option::Option<CS_TYPE_FROM_NETCS_ROUTINE>,
4224 }
4225 impl NDR_CS_SIZE_CONVERT_ROUTINES {}
4226 impl ::std::default::Default for NDR_CS_SIZE_CONVERT_ROUTINES {
default() -> Self4227     fn default() -> Self {
4228         unsafe { ::std::mem::zeroed() }
4229     }
4230 }
4231 impl ::std::fmt::Debug for NDR_CS_SIZE_CONVERT_ROUTINES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4233         fmt.debug_struct("NDR_CS_SIZE_CONVERT_ROUTINES").finish()
4234     }
4235 }
4236 impl ::std::cmp::PartialEq for NDR_CS_SIZE_CONVERT_ROUTINES {
eq(&self, other: &Self) -> bool4237     fn eq(&self, other: &Self) -> bool {
4238         self.pfnNetSize.map(|f| f as usize) == other.pfnNetSize.map(|f| f as usize) && self.pfnToNetCs.map(|f| f as usize) == other.pfnToNetCs.map(|f| f as usize) && self.pfnLocalSize.map(|f| f as usize) == other.pfnLocalSize.map(|f| f as usize) && self.pfnFromNetCs.map(|f| f as usize) == other.pfnFromNetCs.map(|f| f as usize)
4239     }
4240 }
4241 impl ::std::cmp::Eq for NDR_CS_SIZE_CONVERT_ROUTINES {}
4242 unsafe impl ::windows::runtime::Abi for NDR_CS_SIZE_CONVERT_ROUTINES {
4243     type Abi = ::std::mem::ManuallyDrop<Self>;
4244     type DefaultType = Self;
4245 }
4246 pub const NDR_CUSTOM_OR_DEFAULT_ALLOCATOR: u32 = 268435456u32;
4247 pub const NDR_DEFAULT_ALLOCATOR: u32 = 536870912u32;
4248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4249 #[repr(C)]
4250 pub struct NDR_EXPR_DESC {
4251     pub pOffset: *mut u16,
4252     pub pFormatExpr: *mut u8,
4253 }
4254 impl NDR_EXPR_DESC {}
4255 impl ::std::default::Default for NDR_EXPR_DESC {
default() -> Self4256     fn default() -> Self {
4257         unsafe { ::std::mem::zeroed() }
4258     }
4259 }
4260 impl ::std::fmt::Debug for NDR_EXPR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4261     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4262         fmt.debug_struct("NDR_EXPR_DESC").field("pOffset", &self.pOffset).field("pFormatExpr", &self.pFormatExpr).finish()
4263     }
4264 }
4265 impl ::std::cmp::PartialEq for NDR_EXPR_DESC {
eq(&self, other: &Self) -> bool4266     fn eq(&self, other: &Self) -> bool {
4267         self.pOffset == other.pOffset && self.pFormatExpr == other.pFormatExpr
4268     }
4269 }
4270 impl ::std::cmp::Eq for NDR_EXPR_DESC {}
4271 unsafe impl ::windows::runtime::Abi for NDR_EXPR_DESC {
4272     type Abi = Self;
4273     type DefaultType = Self;
4274 }
4275 pub type NDR_NOTIFY2_ROUTINE = unsafe extern "system" fn(flag: u8);
4276 pub type NDR_NOTIFY_ROUTINE = unsafe extern "system" fn();
4277 #[repr(C)]
4278 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
4279 pub struct NDR_POINTER_QUEUE_STATE(pub u8);
4280 pub type NDR_RUNDOWN = unsafe extern "system" fn(context: *mut ::std::ffi::c_void);
4281 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4282 #[repr(C)]
4283 pub struct NDR_SCONTEXT_1 {
4284     pub pad: [*mut ::std::ffi::c_void; 2],
4285     pub userContext: *mut ::std::ffi::c_void,
4286 }
4287 impl NDR_SCONTEXT_1 {}
4288 impl ::std::default::Default for NDR_SCONTEXT_1 {
default() -> Self4289     fn default() -> Self {
4290         unsafe { ::std::mem::zeroed() }
4291     }
4292 }
4293 impl ::std::fmt::Debug for NDR_SCONTEXT_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4294     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4295         fmt.debug_struct("NDR_SCONTEXT_1").field("pad", &self.pad).field("userContext", &self.userContext).finish()
4296     }
4297 }
4298 impl ::std::cmp::PartialEq for NDR_SCONTEXT_1 {
eq(&self, other: &Self) -> bool4299     fn eq(&self, other: &Self) -> bool {
4300         self.pad == other.pad && self.userContext == other.userContext
4301     }
4302 }
4303 impl ::std::cmp::Eq for NDR_SCONTEXT_1 {}
4304 unsafe impl ::windows::runtime::Abi for NDR_SCONTEXT_1 {
4305     type Abi = Self;
4306     type DefaultType = Self;
4307 }
4308 #[cfg(feature = "Win32_System_Com")]
4309 impl ::std::clone::Clone for NDR_USER_MARSHAL_INFO {
clone(&self) -> Self4310     fn clone(&self) -> Self {
4311         unimplemented!()
4312     }
4313 }
4314 #[repr(C)]
4315 #[cfg(feature = "Win32_System_Com")]
4316 pub struct NDR_USER_MARSHAL_INFO {
4317     pub InformationLevel: u32,
4318     pub Anonymous: NDR_USER_MARSHAL_INFO_0,
4319 }
4320 #[cfg(feature = "Win32_System_Com")]
4321 impl NDR_USER_MARSHAL_INFO {}
4322 #[cfg(feature = "Win32_System_Com")]
4323 impl ::std::default::Default for NDR_USER_MARSHAL_INFO {
default() -> Self4324     fn default() -> Self {
4325         unsafe { ::std::mem::zeroed() }
4326     }
4327 }
4328 #[cfg(feature = "Win32_System_Com")]
4329 impl ::std::cmp::PartialEq for NDR_USER_MARSHAL_INFO {
eq(&self, _other: &Self) -> bool4330     fn eq(&self, _other: &Self) -> bool {
4331         unimplemented!()
4332     }
4333 }
4334 #[cfg(feature = "Win32_System_Com")]
4335 impl ::std::cmp::Eq for NDR_USER_MARSHAL_INFO {}
4336 #[cfg(feature = "Win32_System_Com")]
4337 unsafe impl ::windows::runtime::Abi for NDR_USER_MARSHAL_INFO {
4338     type Abi = ::std::mem::ManuallyDrop<Self>;
4339     type DefaultType = Self;
4340 }
4341 #[cfg(feature = "Win32_System_Com")]
4342 impl ::std::clone::Clone for NDR_USER_MARSHAL_INFO_0 {
clone(&self) -> Self4343     fn clone(&self) -> Self {
4344         unimplemented!()
4345     }
4346 }
4347 #[repr(C)]
4348 #[cfg(feature = "Win32_System_Com")]
4349 pub union NDR_USER_MARSHAL_INFO_0 {
4350     pub Level1: ::std::mem::ManuallyDrop<NDR_USER_MARSHAL_INFO_LEVEL1>,
4351 }
4352 #[cfg(feature = "Win32_System_Com")]
4353 impl NDR_USER_MARSHAL_INFO_0 {}
4354 #[cfg(feature = "Win32_System_Com")]
4355 impl ::std::default::Default for NDR_USER_MARSHAL_INFO_0 {
default() -> Self4356     fn default() -> Self {
4357         unsafe { ::std::mem::zeroed() }
4358     }
4359 }
4360 #[cfg(feature = "Win32_System_Com")]
4361 impl ::std::cmp::PartialEq for NDR_USER_MARSHAL_INFO_0 {
eq(&self, _other: &Self) -> bool4362     fn eq(&self, _other: &Self) -> bool {
4363         unimplemented!()
4364     }
4365 }
4366 #[cfg(feature = "Win32_System_Com")]
4367 impl ::std::cmp::Eq for NDR_USER_MARSHAL_INFO_0 {}
4368 #[cfg(feature = "Win32_System_Com")]
4369 unsafe impl ::windows::runtime::Abi for NDR_USER_MARSHAL_INFO_0 {
4370     type Abi = ::std::mem::ManuallyDrop<Self>;
4371     type DefaultType = Self;
4372 }
4373 #[derive(:: std :: clone :: Clone)]
4374 #[repr(C)]
4375 #[cfg(feature = "Win32_System_Com")]
4376 pub struct NDR_USER_MARSHAL_INFO_LEVEL1 {
4377     pub Buffer: *mut ::std::ffi::c_void,
4378     pub BufferSize: u32,
4379     pub pfnAllocate: isize,
4380     pub pfnFree: isize,
4381     pub pRpcChannelBuffer: ::std::option::Option<super::Com::IRpcChannelBuffer>,
4382     pub Reserved: [usize; 5],
4383 }
4384 #[cfg(feature = "Win32_System_Com")]
4385 impl NDR_USER_MARSHAL_INFO_LEVEL1 {}
4386 #[cfg(feature = "Win32_System_Com")]
4387 impl ::std::default::Default for NDR_USER_MARSHAL_INFO_LEVEL1 {
default() -> Self4388     fn default() -> Self {
4389         unsafe { ::std::mem::zeroed() }
4390     }
4391 }
4392 #[cfg(feature = "Win32_System_Com")]
4393 impl ::std::fmt::Debug for NDR_USER_MARSHAL_INFO_LEVEL1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4394     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4395         fmt.debug_struct("NDR_USER_MARSHAL_INFO_LEVEL1").field("Buffer", &self.Buffer).field("BufferSize", &self.BufferSize).field("pfnAllocate", &self.pfnAllocate).field("pfnFree", &self.pfnFree).field("pRpcChannelBuffer", &self.pRpcChannelBuffer).field("Reserved", &self.Reserved).finish()
4396     }
4397 }
4398 #[cfg(feature = "Win32_System_Com")]
4399 impl ::std::cmp::PartialEq for NDR_USER_MARSHAL_INFO_LEVEL1 {
eq(&self, other: &Self) -> bool4400     fn eq(&self, other: &Self) -> bool {
4401         self.Buffer == other.Buffer && self.BufferSize == other.BufferSize && self.pfnAllocate == other.pfnAllocate && self.pfnFree == other.pfnFree && self.pRpcChannelBuffer == other.pRpcChannelBuffer && self.Reserved == other.Reserved
4402     }
4403 }
4404 #[cfg(feature = "Win32_System_Com")]
4405 impl ::std::cmp::Eq for NDR_USER_MARSHAL_INFO_LEVEL1 {}
4406 #[cfg(feature = "Win32_System_Com")]
4407 unsafe impl ::windows::runtime::Abi for NDR_USER_MARSHAL_INFO_LEVEL1 {
4408     type Abi = ::std::mem::ManuallyDrop<Self>;
4409     type DefaultType = Self;
4410 }
4411 pub const NT351_INTERFACE_SIZE: u32 = 64u32;
4412 #[cfg(feature = "Win32_System_Com")]
4413 #[inline]
Ndr64AsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN4414 pub unsafe fn Ndr64AsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN {
4415     #[cfg(windows)]
4416     {
4417         #[link(name = "windows")]
4418         extern "system" {
4419             fn Ndr64AsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN;
4420         }
4421         ::std::mem::transmute(Ndr64AsyncClientCall(::std::mem::transmute(pproxyinfo), ::std::mem::transmute(nprocnum), ::std::mem::transmute(preturnvalue)))
4422     }
4423     #[cfg(not(windows))]
4424     unimplemented!("Unsupported target OS");
4425 }
4426 #[inline]
Ndr64AsyncServerCall64(prpcmsg: *mut RPC_MESSAGE)4427 pub unsafe fn Ndr64AsyncServerCall64(prpcmsg: *mut RPC_MESSAGE) {
4428     #[cfg(windows)]
4429     {
4430         #[link(name = "windows")]
4431         extern "system" {
4432             fn Ndr64AsyncServerCall64(prpcmsg: *mut RPC_MESSAGE);
4433         }
4434         ::std::mem::transmute(Ndr64AsyncServerCall64(::std::mem::transmute(prpcmsg)))
4435     }
4436     #[cfg(not(windows))]
4437     unimplemented!("Unsupported target OS");
4438 }
4439 #[inline]
Ndr64AsyncServerCallAll(prpcmsg: *mut RPC_MESSAGE)4440 pub unsafe fn Ndr64AsyncServerCallAll(prpcmsg: *mut RPC_MESSAGE) {
4441     #[cfg(windows)]
4442     {
4443         #[link(name = "windows")]
4444         extern "system" {
4445             fn Ndr64AsyncServerCallAll(prpcmsg: *mut RPC_MESSAGE);
4446         }
4447         ::std::mem::transmute(Ndr64AsyncServerCallAll(::std::mem::transmute(prpcmsg)))
4448     }
4449     #[cfg(not(windows))]
4450     unimplemented!("Unsupported target OS");
4451 }
4452 #[cfg(feature = "Win32_System_Com")]
4453 #[inline]
Ndr64DcomAsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN4454 pub unsafe fn Ndr64DcomAsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN {
4455     #[cfg(windows)]
4456     {
4457         #[link(name = "windows")]
4458         extern "system" {
4459             fn Ndr64DcomAsyncClientCall(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN;
4460         }
4461         ::std::mem::transmute(Ndr64DcomAsyncClientCall(::std::mem::transmute(pproxyinfo), ::std::mem::transmute(nprocnum), ::std::mem::transmute(preturnvalue)))
4462     }
4463     #[cfg(not(windows))]
4464     unimplemented!("Unsupported target OS");
4465 }
4466 #[cfg(feature = "Win32_System_Com")]
4467 #[inline]
Ndr64DcomAsyncStubCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>, Param1: ::windows::runtime::IntoParam<'a, super::Com::IRpcChannelBuffer>>(pthis: Param0, pchannel: Param1, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i324468 pub unsafe fn Ndr64DcomAsyncStubCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>, Param1: ::windows::runtime::IntoParam<'a, super::Com::IRpcChannelBuffer>>(pthis: Param0, pchannel: Param1, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32 {
4469     #[cfg(windows)]
4470     {
4471         #[link(name = "windows")]
4472         extern "system" {
4473             fn Ndr64DcomAsyncStubCall(pthis: ::windows::runtime::RawPtr, pchannel: ::windows::runtime::RawPtr, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32;
4474         }
4475         ::std::mem::transmute(Ndr64DcomAsyncStubCall(pthis.into_param().abi(), pchannel.into_param().abi(), ::std::mem::transmute(prpcmsg), ::std::mem::transmute(pdwstubphase)))
4476     }
4477     #[cfg(not(windows))]
4478     unimplemented!("Unsupported target OS");
4479 }
4480 #[cfg(feature = "Win32_System_Com")]
4481 #[inline]
NdrAllocate(pstubmsg: *mut MIDL_STUB_MESSAGE, len: usize) -> *mut ::std::ffi::c_void4482 pub unsafe fn NdrAllocate(pstubmsg: *mut MIDL_STUB_MESSAGE, len: usize) -> *mut ::std::ffi::c_void {
4483     #[cfg(windows)]
4484     {
4485         #[link(name = "windows")]
4486         extern "system" {
4487             fn NdrAllocate(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, len: usize) -> *mut ::std::ffi::c_void;
4488         }
4489         ::std::mem::transmute(NdrAllocate(::std::mem::transmute(pstubmsg), ::std::mem::transmute(len)))
4490     }
4491     #[cfg(not(windows))]
4492     unimplemented!("Unsupported target OS");
4493 }
4494 #[cfg(feature = "Win32_System_Com")]
4495 #[inline]
NdrAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN4496 pub unsafe fn NdrAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN {
4497     #[cfg(windows)]
4498     {
4499         #[link(name = "windows")]
4500         extern "system" {
4501             fn NdrAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN;
4502         }
4503         ::std::mem::transmute(NdrAsyncClientCall(::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(pformat)))
4504     }
4505     #[cfg(not(windows))]
4506     unimplemented!("Unsupported target OS");
4507 }
4508 #[inline]
NdrAsyncServerCall(prpcmsg: *mut RPC_MESSAGE)4509 pub unsafe fn NdrAsyncServerCall(prpcmsg: *mut RPC_MESSAGE) {
4510     #[cfg(windows)]
4511     {
4512         #[link(name = "windows")]
4513         extern "system" {
4514             fn NdrAsyncServerCall(prpcmsg: *mut RPC_MESSAGE);
4515         }
4516         ::std::mem::transmute(NdrAsyncServerCall(::std::mem::transmute(prpcmsg)))
4517     }
4518     #[cfg(not(windows))]
4519     unimplemented!("Unsupported target OS");
4520 }
4521 #[cfg(feature = "Win32_System_Com")]
4522 #[inline]
NdrByteCountPointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4523 pub unsafe fn NdrByteCountPointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4524     #[cfg(windows)]
4525     {
4526         #[link(name = "windows")]
4527         extern "system" {
4528             fn NdrByteCountPointerBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4529         }
4530         ::std::mem::transmute(NdrByteCountPointerBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4531     }
4532     #[cfg(not(windows))]
4533     unimplemented!("Unsupported target OS");
4534 }
4535 #[cfg(feature = "Win32_System_Com")]
4536 #[inline]
NdrByteCountPointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4537 pub unsafe fn NdrByteCountPointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4538     #[cfg(windows)]
4539     {
4540         #[link(name = "windows")]
4541         extern "system" {
4542             fn NdrByteCountPointerFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4543         }
4544         ::std::mem::transmute(NdrByteCountPointerFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4545     }
4546     #[cfg(not(windows))]
4547     unimplemented!("Unsupported target OS");
4548 }
4549 #[cfg(feature = "Win32_System_Com")]
4550 #[inline]
NdrByteCountPointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84551 pub unsafe fn NdrByteCountPointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4552     #[cfg(windows)]
4553     {
4554         #[link(name = "windows")]
4555         extern "system" {
4556             fn NdrByteCountPointerMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4557         }
4558         ::std::mem::transmute(NdrByteCountPointerMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4559     }
4560     #[cfg(not(windows))]
4561     unimplemented!("Unsupported target OS");
4562 }
4563 #[cfg(feature = "Win32_System_Com")]
4564 #[inline]
NdrByteCountPointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84565 pub unsafe fn NdrByteCountPointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
4566     #[cfg(windows)]
4567     {
4568         #[link(name = "windows")]
4569         extern "system" {
4570             fn NdrByteCountPointerUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
4571         }
4572         ::std::mem::transmute(NdrByteCountPointerUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
4573     }
4574     #[cfg(not(windows))]
4575     unimplemented!("Unsupported target OS");
4576 }
4577 #[cfg(feature = "Win32_System_Com")]
4578 #[inline]
NdrClearOutParameters(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8, argaddr: *mut ::std::ffi::c_void)4579 pub unsafe fn NdrClearOutParameters(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8, argaddr: *mut ::std::ffi::c_void) {
4580     #[cfg(windows)]
4581     {
4582         #[link(name = "windows")]
4583         extern "system" {
4584             fn NdrClearOutParameters(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8, argaddr: *mut ::std::ffi::c_void);
4585         }
4586         ::std::mem::transmute(NdrClearOutParameters(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat), ::std::mem::transmute(argaddr)))
4587     }
4588     #[cfg(not(windows))]
4589     unimplemented!("Unsupported target OS");
4590 }
4591 #[cfg(feature = "Win32_System_Com")]
4592 #[inline]
NdrClientCall2(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN4593 pub unsafe fn NdrClientCall2(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN {
4594     #[cfg(windows)]
4595     {
4596         #[link(name = "windows")]
4597         extern "system" {
4598             fn NdrClientCall2(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN;
4599         }
4600         ::std::mem::transmute(NdrClientCall2(::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(pformat)))
4601     }
4602     #[cfg(not(windows))]
4603     unimplemented!("Unsupported target OS");
4604 }
4605 #[cfg(feature = "Win32_System_Com")]
4606 #[inline]
NdrClientCall3(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN4607 pub unsafe fn NdrClientCall3(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN {
4608     #[cfg(windows)]
4609     {
4610         #[link(name = "windows")]
4611         extern "system" {
4612             fn NdrClientCall3(pproxyinfo: *mut MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN;
4613         }
4614         ::std::mem::transmute(NdrClientCall3(::std::mem::transmute(pproxyinfo), ::std::mem::transmute(nprocnum), ::std::mem::transmute(preturnvalue)))
4615     }
4616     #[cfg(not(windows))]
4617     unimplemented!("Unsupported target OS");
4618 }
4619 #[cfg(feature = "Win32_System_Com")]
4620 #[inline]
NdrClientContextMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: isize, fcheck: i32)4621 pub unsafe fn NdrClientContextMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: isize, fcheck: i32) {
4622     #[cfg(windows)]
4623     {
4624         #[link(name = "windows")]
4625         extern "system" {
4626             fn NdrClientContextMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, contexthandle: isize, fcheck: i32);
4627         }
4628         ::std::mem::transmute(NdrClientContextMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(contexthandle), ::std::mem::transmute(fcheck)))
4629     }
4630     #[cfg(not(windows))]
4631     unimplemented!("Unsupported target OS");
4632 }
4633 #[cfg(feature = "Win32_System_Com")]
4634 #[inline]
NdrClientContextUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pcontexthandle: *mut isize, bindhandle: *mut ::std::ffi::c_void)4635 pub unsafe fn NdrClientContextUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pcontexthandle: *mut isize, bindhandle: *mut ::std::ffi::c_void) {
4636     #[cfg(windows)]
4637     {
4638         #[link(name = "windows")]
4639         extern "system" {
4640             fn NdrClientContextUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pcontexthandle: *mut isize, bindhandle: *mut ::std::ffi::c_void);
4641         }
4642         ::std::mem::transmute(NdrClientContextUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pcontexthandle), ::std::mem::transmute(bindhandle)))
4643     }
4644     #[cfg(not(windows))]
4645     unimplemented!("Unsupported target OS");
4646 }
4647 #[cfg(feature = "Win32_System_Com")]
4648 #[inline]
NdrClientInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32)4649 pub unsafe fn NdrClientInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32) {
4650     #[cfg(windows)]
4651     {
4652         #[link(name = "windows")]
4653         extern "system" {
4654             fn NdrClientInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32);
4655         }
4656         ::std::mem::transmute(NdrClientInitialize(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(procnum)))
4657     }
4658     #[cfg(not(windows))]
4659     unimplemented!("Unsupported target OS");
4660 }
4661 #[cfg(feature = "Win32_System_Com")]
4662 #[inline]
NdrClientInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32)4663 pub unsafe fn NdrClientInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32) {
4664     #[cfg(windows)]
4665     {
4666         #[link(name = "windows")]
4667         extern "system" {
4668             fn NdrClientInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC, procnum: u32);
4669         }
4670         ::std::mem::transmute(NdrClientInitializeNew(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(procnum)))
4671     }
4672     #[cfg(not(windows))]
4673     unimplemented!("Unsupported target OS");
4674 }
4675 #[cfg(feature = "Win32_System_Com")]
4676 #[inline]
NdrComplexArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4677 pub unsafe fn NdrComplexArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4678     #[cfg(windows)]
4679     {
4680         #[link(name = "windows")]
4681         extern "system" {
4682             fn NdrComplexArrayBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4683         }
4684         ::std::mem::transmute(NdrComplexArrayBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4685     }
4686     #[cfg(not(windows))]
4687     unimplemented!("Unsupported target OS");
4688 }
4689 #[cfg(feature = "Win32_System_Com")]
4690 #[inline]
NdrComplexArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4691 pub unsafe fn NdrComplexArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4692     #[cfg(windows)]
4693     {
4694         #[link(name = "windows")]
4695         extern "system" {
4696             fn NdrComplexArrayFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4697         }
4698         ::std::mem::transmute(NdrComplexArrayFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4699     }
4700     #[cfg(not(windows))]
4701     unimplemented!("Unsupported target OS");
4702 }
4703 #[cfg(feature = "Win32_System_Com")]
4704 #[inline]
NdrComplexArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84705 pub unsafe fn NdrComplexArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4706     #[cfg(windows)]
4707     {
4708         #[link(name = "windows")]
4709         extern "system" {
4710             fn NdrComplexArrayMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4711         }
4712         ::std::mem::transmute(NdrComplexArrayMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4713     }
4714     #[cfg(not(windows))]
4715     unimplemented!("Unsupported target OS");
4716 }
4717 #[cfg(feature = "Win32_System_Com")]
4718 #[inline]
NdrComplexArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u324719 pub unsafe fn NdrComplexArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
4720     #[cfg(windows)]
4721     {
4722         #[link(name = "windows")]
4723         extern "system" {
4724             fn NdrComplexArrayMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
4725         }
4726         ::std::mem::transmute(NdrComplexArrayMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
4727     }
4728     #[cfg(not(windows))]
4729     unimplemented!("Unsupported target OS");
4730 }
4731 #[cfg(feature = "Win32_System_Com")]
4732 #[inline]
NdrComplexArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84733 pub unsafe fn NdrComplexArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
4734     #[cfg(windows)]
4735     {
4736         #[link(name = "windows")]
4737         extern "system" {
4738             fn NdrComplexArrayUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
4739         }
4740         ::std::mem::transmute(NdrComplexArrayUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
4741     }
4742     #[cfg(not(windows))]
4743     unimplemented!("Unsupported target OS");
4744 }
4745 #[cfg(feature = "Win32_System_Com")]
4746 #[inline]
NdrComplexStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4747 pub unsafe fn NdrComplexStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4748     #[cfg(windows)]
4749     {
4750         #[link(name = "windows")]
4751         extern "system" {
4752             fn NdrComplexStructBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4753         }
4754         ::std::mem::transmute(NdrComplexStructBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4755     }
4756     #[cfg(not(windows))]
4757     unimplemented!("Unsupported target OS");
4758 }
4759 #[cfg(feature = "Win32_System_Com")]
4760 #[inline]
NdrComplexStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4761 pub unsafe fn NdrComplexStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4762     #[cfg(windows)]
4763     {
4764         #[link(name = "windows")]
4765         extern "system" {
4766             fn NdrComplexStructFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4767         }
4768         ::std::mem::transmute(NdrComplexStructFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4769     }
4770     #[cfg(not(windows))]
4771     unimplemented!("Unsupported target OS");
4772 }
4773 #[cfg(feature = "Win32_System_Com")]
4774 #[inline]
NdrComplexStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84775 pub unsafe fn NdrComplexStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4776     #[cfg(windows)]
4777     {
4778         #[link(name = "windows")]
4779         extern "system" {
4780             fn NdrComplexStructMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4781         }
4782         ::std::mem::transmute(NdrComplexStructMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4783     }
4784     #[cfg(not(windows))]
4785     unimplemented!("Unsupported target OS");
4786 }
4787 #[cfg(feature = "Win32_System_Com")]
4788 #[inline]
NdrComplexStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u324789 pub unsafe fn NdrComplexStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
4790     #[cfg(windows)]
4791     {
4792         #[link(name = "windows")]
4793         extern "system" {
4794             fn NdrComplexStructMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
4795         }
4796         ::std::mem::transmute(NdrComplexStructMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
4797     }
4798     #[cfg(not(windows))]
4799     unimplemented!("Unsupported target OS");
4800 }
4801 #[cfg(feature = "Win32_System_Com")]
4802 #[inline]
NdrComplexStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84803 pub unsafe fn NdrComplexStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
4804     #[cfg(windows)]
4805     {
4806         #[link(name = "windows")]
4807         extern "system" {
4808             fn NdrComplexStructUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
4809         }
4810         ::std::mem::transmute(NdrComplexStructUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
4811     }
4812     #[cfg(not(windows))]
4813     unimplemented!("Unsupported target OS");
4814 }
4815 #[cfg(feature = "Win32_System_Com")]
4816 #[inline]
NdrConformantArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4817 pub unsafe fn NdrConformantArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4818     #[cfg(windows)]
4819     {
4820         #[link(name = "windows")]
4821         extern "system" {
4822             fn NdrConformantArrayBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4823         }
4824         ::std::mem::transmute(NdrConformantArrayBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4825     }
4826     #[cfg(not(windows))]
4827     unimplemented!("Unsupported target OS");
4828 }
4829 #[cfg(feature = "Win32_System_Com")]
4830 #[inline]
NdrConformantArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4831 pub unsafe fn NdrConformantArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4832     #[cfg(windows)]
4833     {
4834         #[link(name = "windows")]
4835         extern "system" {
4836             fn NdrConformantArrayFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4837         }
4838         ::std::mem::transmute(NdrConformantArrayFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4839     }
4840     #[cfg(not(windows))]
4841     unimplemented!("Unsupported target OS");
4842 }
4843 #[cfg(feature = "Win32_System_Com")]
4844 #[inline]
NdrConformantArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84845 pub unsafe fn NdrConformantArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4846     #[cfg(windows)]
4847     {
4848         #[link(name = "windows")]
4849         extern "system" {
4850             fn NdrConformantArrayMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4851         }
4852         ::std::mem::transmute(NdrConformantArrayMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4853     }
4854     #[cfg(not(windows))]
4855     unimplemented!("Unsupported target OS");
4856 }
4857 #[cfg(feature = "Win32_System_Com")]
4858 #[inline]
NdrConformantArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u324859 pub unsafe fn NdrConformantArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
4860     #[cfg(windows)]
4861     {
4862         #[link(name = "windows")]
4863         extern "system" {
4864             fn NdrConformantArrayMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
4865         }
4866         ::std::mem::transmute(NdrConformantArrayMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
4867     }
4868     #[cfg(not(windows))]
4869     unimplemented!("Unsupported target OS");
4870 }
4871 #[cfg(feature = "Win32_System_Com")]
4872 #[inline]
NdrConformantArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84873 pub unsafe fn NdrConformantArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
4874     #[cfg(windows)]
4875     {
4876         #[link(name = "windows")]
4877         extern "system" {
4878             fn NdrConformantArrayUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
4879         }
4880         ::std::mem::transmute(NdrConformantArrayUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
4881     }
4882     #[cfg(not(windows))]
4883     unimplemented!("Unsupported target OS");
4884 }
4885 #[cfg(feature = "Win32_System_Com")]
4886 #[inline]
NdrConformantStringBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4887 pub unsafe fn NdrConformantStringBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4888     #[cfg(windows)]
4889     {
4890         #[link(name = "windows")]
4891         extern "system" {
4892             fn NdrConformantStringBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4893         }
4894         ::std::mem::transmute(NdrConformantStringBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4895     }
4896     #[cfg(not(windows))]
4897     unimplemented!("Unsupported target OS");
4898 }
4899 #[cfg(feature = "Win32_System_Com")]
4900 #[inline]
NdrConformantStringMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84901 pub unsafe fn NdrConformantStringMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4902     #[cfg(windows)]
4903     {
4904         #[link(name = "windows")]
4905         extern "system" {
4906             fn NdrConformantStringMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4907         }
4908         ::std::mem::transmute(NdrConformantStringMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4909     }
4910     #[cfg(not(windows))]
4911     unimplemented!("Unsupported target OS");
4912 }
4913 #[cfg(feature = "Win32_System_Com")]
4914 #[inline]
NdrConformantStringMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u324915 pub unsafe fn NdrConformantStringMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
4916     #[cfg(windows)]
4917     {
4918         #[link(name = "windows")]
4919         extern "system" {
4920             fn NdrConformantStringMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
4921         }
4922         ::std::mem::transmute(NdrConformantStringMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
4923     }
4924     #[cfg(not(windows))]
4925     unimplemented!("Unsupported target OS");
4926 }
4927 #[cfg(feature = "Win32_System_Com")]
4928 #[inline]
NdrConformantStringUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84929 pub unsafe fn NdrConformantStringUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
4930     #[cfg(windows)]
4931     {
4932         #[link(name = "windows")]
4933         extern "system" {
4934             fn NdrConformantStringUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
4935         }
4936         ::std::mem::transmute(NdrConformantStringUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
4937     }
4938     #[cfg(not(windows))]
4939     unimplemented!("Unsupported target OS");
4940 }
4941 #[cfg(feature = "Win32_System_Com")]
4942 #[inline]
NdrConformantStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4943 pub unsafe fn NdrConformantStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4944     #[cfg(windows)]
4945     {
4946         #[link(name = "windows")]
4947         extern "system" {
4948             fn NdrConformantStructBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4949         }
4950         ::std::mem::transmute(NdrConformantStructBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4951     }
4952     #[cfg(not(windows))]
4953     unimplemented!("Unsupported target OS");
4954 }
4955 #[cfg(feature = "Win32_System_Com")]
4956 #[inline]
NdrConformantStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)4957 pub unsafe fn NdrConformantStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
4958     #[cfg(windows)]
4959     {
4960         #[link(name = "windows")]
4961         extern "system" {
4962             fn NdrConformantStructFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
4963         }
4964         ::std::mem::transmute(NdrConformantStructFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4965     }
4966     #[cfg(not(windows))]
4967     unimplemented!("Unsupported target OS");
4968 }
4969 #[cfg(feature = "Win32_System_Com")]
4970 #[inline]
NdrConformantStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u84971 pub unsafe fn NdrConformantStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
4972     #[cfg(windows)]
4973     {
4974         #[link(name = "windows")]
4975         extern "system" {
4976             fn NdrConformantStructMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
4977         }
4978         ::std::mem::transmute(NdrConformantStructMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
4979     }
4980     #[cfg(not(windows))]
4981     unimplemented!("Unsupported target OS");
4982 }
4983 #[cfg(feature = "Win32_System_Com")]
4984 #[inline]
NdrConformantStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u324985 pub unsafe fn NdrConformantStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
4986     #[cfg(windows)]
4987     {
4988         #[link(name = "windows")]
4989         extern "system" {
4990             fn NdrConformantStructMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
4991         }
4992         ::std::mem::transmute(NdrConformantStructMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
4993     }
4994     #[cfg(not(windows))]
4995     unimplemented!("Unsupported target OS");
4996 }
4997 #[cfg(feature = "Win32_System_Com")]
4998 #[inline]
NdrConformantStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u84999 pub unsafe fn NdrConformantStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5000     #[cfg(windows)]
5001     {
5002         #[link(name = "windows")]
5003         extern "system" {
5004             fn NdrConformantStructUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5005         }
5006         ::std::mem::transmute(NdrConformantStructUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5007     }
5008     #[cfg(not(windows))]
5009     unimplemented!("Unsupported target OS");
5010 }
5011 #[cfg(feature = "Win32_System_Com")]
5012 #[inline]
NdrConformantVaryingArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5013 pub unsafe fn NdrConformantVaryingArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5014     #[cfg(windows)]
5015     {
5016         #[link(name = "windows")]
5017         extern "system" {
5018             fn NdrConformantVaryingArrayBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5019         }
5020         ::std::mem::transmute(NdrConformantVaryingArrayBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5021     }
5022     #[cfg(not(windows))]
5023     unimplemented!("Unsupported target OS");
5024 }
5025 #[cfg(feature = "Win32_System_Com")]
5026 #[inline]
NdrConformantVaryingArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5027 pub unsafe fn NdrConformantVaryingArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5028     #[cfg(windows)]
5029     {
5030         #[link(name = "windows")]
5031         extern "system" {
5032             fn NdrConformantVaryingArrayFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5033         }
5034         ::std::mem::transmute(NdrConformantVaryingArrayFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5035     }
5036     #[cfg(not(windows))]
5037     unimplemented!("Unsupported target OS");
5038 }
5039 #[cfg(feature = "Win32_System_Com")]
5040 #[inline]
NdrConformantVaryingArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85041 pub unsafe fn NdrConformantVaryingArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5042     #[cfg(windows)]
5043     {
5044         #[link(name = "windows")]
5045         extern "system" {
5046             fn NdrConformantVaryingArrayMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5047         }
5048         ::std::mem::transmute(NdrConformantVaryingArrayMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5049     }
5050     #[cfg(not(windows))]
5051     unimplemented!("Unsupported target OS");
5052 }
5053 #[cfg(feature = "Win32_System_Com")]
5054 #[inline]
NdrConformantVaryingArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325055 pub unsafe fn NdrConformantVaryingArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5056     #[cfg(windows)]
5057     {
5058         #[link(name = "windows")]
5059         extern "system" {
5060             fn NdrConformantVaryingArrayMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5061         }
5062         ::std::mem::transmute(NdrConformantVaryingArrayMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5063     }
5064     #[cfg(not(windows))]
5065     unimplemented!("Unsupported target OS");
5066 }
5067 #[cfg(feature = "Win32_System_Com")]
5068 #[inline]
NdrConformantVaryingArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85069 pub unsafe fn NdrConformantVaryingArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5070     #[cfg(windows)]
5071     {
5072         #[link(name = "windows")]
5073         extern "system" {
5074             fn NdrConformantVaryingArrayUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5075         }
5076         ::std::mem::transmute(NdrConformantVaryingArrayUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5077     }
5078     #[cfg(not(windows))]
5079     unimplemented!("Unsupported target OS");
5080 }
5081 #[cfg(feature = "Win32_System_Com")]
5082 #[inline]
NdrConformantVaryingStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5083 pub unsafe fn NdrConformantVaryingStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5084     #[cfg(windows)]
5085     {
5086         #[link(name = "windows")]
5087         extern "system" {
5088             fn NdrConformantVaryingStructBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5089         }
5090         ::std::mem::transmute(NdrConformantVaryingStructBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5091     }
5092     #[cfg(not(windows))]
5093     unimplemented!("Unsupported target OS");
5094 }
5095 #[cfg(feature = "Win32_System_Com")]
5096 #[inline]
NdrConformantVaryingStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5097 pub unsafe fn NdrConformantVaryingStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5098     #[cfg(windows)]
5099     {
5100         #[link(name = "windows")]
5101         extern "system" {
5102             fn NdrConformantVaryingStructFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5103         }
5104         ::std::mem::transmute(NdrConformantVaryingStructFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5105     }
5106     #[cfg(not(windows))]
5107     unimplemented!("Unsupported target OS");
5108 }
5109 #[cfg(feature = "Win32_System_Com")]
5110 #[inline]
NdrConformantVaryingStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85111 pub unsafe fn NdrConformantVaryingStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5112     #[cfg(windows)]
5113     {
5114         #[link(name = "windows")]
5115         extern "system" {
5116             fn NdrConformantVaryingStructMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5117         }
5118         ::std::mem::transmute(NdrConformantVaryingStructMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5119     }
5120     #[cfg(not(windows))]
5121     unimplemented!("Unsupported target OS");
5122 }
5123 #[cfg(feature = "Win32_System_Com")]
5124 #[inline]
NdrConformantVaryingStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325125 pub unsafe fn NdrConformantVaryingStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5126     #[cfg(windows)]
5127     {
5128         #[link(name = "windows")]
5129         extern "system" {
5130             fn NdrConformantVaryingStructMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5131         }
5132         ::std::mem::transmute(NdrConformantVaryingStructMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5133     }
5134     #[cfg(not(windows))]
5135     unimplemented!("Unsupported target OS");
5136 }
5137 #[cfg(feature = "Win32_System_Com")]
5138 #[inline]
NdrConformantVaryingStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85139 pub unsafe fn NdrConformantVaryingStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5140     #[cfg(windows)]
5141     {
5142         #[link(name = "windows")]
5143         extern "system" {
5144             fn NdrConformantVaryingStructUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5145         }
5146         ::std::mem::transmute(NdrConformantVaryingStructUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5147     }
5148     #[cfg(not(windows))]
5149     unimplemented!("Unsupported target OS");
5150 }
5151 #[cfg(feature = "Win32_System_Com")]
5152 #[inline]
NdrContextHandleInitialize(pstubmsg: *const MIDL_STUB_MESSAGE, pformat: *const u8) -> *mut NDR_SCONTEXT_15153 pub unsafe fn NdrContextHandleInitialize(pstubmsg: *const MIDL_STUB_MESSAGE, pformat: *const u8) -> *mut NDR_SCONTEXT_1 {
5154     #[cfg(windows)]
5155     {
5156         #[link(name = "windows")]
5157         extern "system" {
5158             fn NdrContextHandleInitialize(pstubmsg: *const ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *const u8) -> *mut NDR_SCONTEXT_1;
5159         }
5160         ::std::mem::transmute(NdrContextHandleInitialize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5161     }
5162     #[cfg(not(windows))]
5163     unimplemented!("Unsupported target OS");
5164 }
5165 #[cfg(feature = "Win32_System_Com")]
5166 #[inline]
NdrContextHandleSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5167 pub unsafe fn NdrContextHandleSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5168     #[cfg(windows)]
5169     {
5170         #[link(name = "windows")]
5171         extern "system" {
5172             fn NdrContextHandleSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5173         }
5174         ::std::mem::transmute(NdrContextHandleSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5175     }
5176     #[cfg(not(windows))]
5177     unimplemented!("Unsupported target OS");
5178 }
5179 #[cfg(feature = "Win32_System_Com")]
5180 #[inline]
NdrConvert(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8)5181 pub unsafe fn NdrConvert(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) {
5182     #[cfg(windows)]
5183     {
5184         #[link(name = "windows")]
5185         extern "system" {
5186             fn NdrConvert(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8);
5187         }
5188         ::std::mem::transmute(NdrConvert(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5189     }
5190     #[cfg(not(windows))]
5191     unimplemented!("Unsupported target OS");
5192 }
5193 #[cfg(feature = "Win32_System_Com")]
5194 #[inline]
NdrConvert2(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8, numberparams: i32)5195 pub unsafe fn NdrConvert2(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8, numberparams: i32) {
5196     #[cfg(windows)]
5197     {
5198         #[link(name = "windows")]
5199         extern "system" {
5200             fn NdrConvert2(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8, numberparams: i32);
5201         }
5202         ::std::mem::transmute(NdrConvert2(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat), ::std::mem::transmute(numberparams)))
5203     }
5204     #[cfg(not(windows))]
5205     unimplemented!("Unsupported target OS");
5206 }
5207 #[cfg(feature = "Win32_System_Com")]
5208 #[inline]
NdrCorrelationFree(pstubmsg: *mut MIDL_STUB_MESSAGE)5209 pub unsafe fn NdrCorrelationFree(pstubmsg: *mut MIDL_STUB_MESSAGE) {
5210     #[cfg(windows)]
5211     {
5212         #[link(name = "windows")]
5213         extern "system" {
5214             fn NdrCorrelationFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
5215         }
5216         ::std::mem::transmute(NdrCorrelationFree(::std::mem::transmute(pstubmsg)))
5217     }
5218     #[cfg(not(windows))]
5219     unimplemented!("Unsupported target OS");
5220 }
5221 #[cfg(feature = "Win32_System_Com")]
5222 #[inline]
NdrCorrelationInitialize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void, cachesize: u32, flags: u32)5223 pub unsafe fn NdrCorrelationInitialize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void, cachesize: u32, flags: u32) {
5224     #[cfg(windows)]
5225     {
5226         #[link(name = "windows")]
5227         extern "system" {
5228             fn NdrCorrelationInitialize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut ::std::ffi::c_void, cachesize: u32, flags: u32);
5229         }
5230         ::std::mem::transmute(NdrCorrelationInitialize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(cachesize), ::std::mem::transmute(flags)))
5231     }
5232     #[cfg(not(windows))]
5233     unimplemented!("Unsupported target OS");
5234 }
5235 #[cfg(feature = "Win32_System_Com")]
5236 #[inline]
NdrCorrelationPass(pstubmsg: *mut MIDL_STUB_MESSAGE)5237 pub unsafe fn NdrCorrelationPass(pstubmsg: *mut MIDL_STUB_MESSAGE) {
5238     #[cfg(windows)]
5239     {
5240         #[link(name = "windows")]
5241         extern "system" {
5242             fn NdrCorrelationPass(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
5243         }
5244         ::std::mem::transmute(NdrCorrelationPass(::std::mem::transmute(pstubmsg)))
5245     }
5246     #[cfg(not(windows))]
5247     unimplemented!("Unsupported target OS");
5248 }
5249 #[cfg(feature = "Win32_System_Com")]
5250 #[inline]
NdrCreateServerInterfaceFromStub<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>>(pstub: Param0, pserverif: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS5251 pub unsafe fn NdrCreateServerInterfaceFromStub<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>>(pstub: Param0, pserverif: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS {
5252     #[cfg(windows)]
5253     {
5254         #[link(name = "windows")]
5255         extern "system" {
5256             fn NdrCreateServerInterfaceFromStub(pstub: ::windows::runtime::RawPtr, pserverif: *mut RPC_SERVER_INTERFACE) -> RPC_STATUS;
5257         }
5258         ::std::mem::transmute(NdrCreateServerInterfaceFromStub(pstub.into_param().abi(), ::std::mem::transmute(pserverif)))
5259     }
5260     #[cfg(not(windows))]
5261     unimplemented!("Unsupported target OS");
5262 }
5263 #[cfg(feature = "Win32_System_Com")]
5264 #[inline]
NdrDcomAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN5265 pub unsafe fn NdrDcomAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN {
5266     #[cfg(windows)]
5267     {
5268         #[link(name = "windows")]
5269         extern "system" {
5270             fn NdrDcomAsyncClientCall(pstubdescriptor: *mut MIDL_STUB_DESC, pformat: *mut u8) -> CLIENT_CALL_RETURN;
5271         }
5272         ::std::mem::transmute(NdrDcomAsyncClientCall(::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(pformat)))
5273     }
5274     #[cfg(not(windows))]
5275     unimplemented!("Unsupported target OS");
5276 }
5277 #[cfg(feature = "Win32_System_Com")]
5278 #[inline]
NdrDcomAsyncStubCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>, Param1: ::windows::runtime::IntoParam<'a, super::Com::IRpcChannelBuffer>>(pthis: Param0, pchannel: Param1, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i325279 pub unsafe fn NdrDcomAsyncStubCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::Com::IRpcStubBuffer>, Param1: ::windows::runtime::IntoParam<'a, super::Com::IRpcChannelBuffer>>(pthis: Param0, pchannel: Param1, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32 {
5280     #[cfg(windows)]
5281     {
5282         #[link(name = "windows")]
5283         extern "system" {
5284             fn NdrDcomAsyncStubCall(pthis: ::windows::runtime::RawPtr, pchannel: ::windows::runtime::RawPtr, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32;
5285         }
5286         ::std::mem::transmute(NdrDcomAsyncStubCall(pthis.into_param().abi(), pchannel.into_param().abi(), ::std::mem::transmute(prpcmsg), ::std::mem::transmute(pdwstubphase)))
5287     }
5288     #[cfg(not(windows))]
5289     unimplemented!("Unsupported target OS");
5290 }
5291 #[cfg(feature = "Win32_System_Com")]
5292 #[inline]
NdrEncapsulatedUnionBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5293 pub unsafe fn NdrEncapsulatedUnionBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5294     #[cfg(windows)]
5295     {
5296         #[link(name = "windows")]
5297         extern "system" {
5298             fn NdrEncapsulatedUnionBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5299         }
5300         ::std::mem::transmute(NdrEncapsulatedUnionBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5301     }
5302     #[cfg(not(windows))]
5303     unimplemented!("Unsupported target OS");
5304 }
5305 #[cfg(feature = "Win32_System_Com")]
5306 #[inline]
NdrEncapsulatedUnionFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5307 pub unsafe fn NdrEncapsulatedUnionFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5308     #[cfg(windows)]
5309     {
5310         #[link(name = "windows")]
5311         extern "system" {
5312             fn NdrEncapsulatedUnionFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5313         }
5314         ::std::mem::transmute(NdrEncapsulatedUnionFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5315     }
5316     #[cfg(not(windows))]
5317     unimplemented!("Unsupported target OS");
5318 }
5319 #[cfg(feature = "Win32_System_Com")]
5320 #[inline]
NdrEncapsulatedUnionMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85321 pub unsafe fn NdrEncapsulatedUnionMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5322     #[cfg(windows)]
5323     {
5324         #[link(name = "windows")]
5325         extern "system" {
5326             fn NdrEncapsulatedUnionMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5327         }
5328         ::std::mem::transmute(NdrEncapsulatedUnionMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5329     }
5330     #[cfg(not(windows))]
5331     unimplemented!("Unsupported target OS");
5332 }
5333 #[cfg(feature = "Win32_System_Com")]
5334 #[inline]
NdrEncapsulatedUnionMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325335 pub unsafe fn NdrEncapsulatedUnionMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5336     #[cfg(windows)]
5337     {
5338         #[link(name = "windows")]
5339         extern "system" {
5340             fn NdrEncapsulatedUnionMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5341         }
5342         ::std::mem::transmute(NdrEncapsulatedUnionMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5343     }
5344     #[cfg(not(windows))]
5345     unimplemented!("Unsupported target OS");
5346 }
5347 #[cfg(feature = "Win32_System_Com")]
5348 #[inline]
NdrEncapsulatedUnionUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85349 pub unsafe fn NdrEncapsulatedUnionUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5350     #[cfg(windows)]
5351     {
5352         #[link(name = "windows")]
5353         extern "system" {
5354             fn NdrEncapsulatedUnionUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5355         }
5356         ::std::mem::transmute(NdrEncapsulatedUnionUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5357     }
5358     #[cfg(not(windows))]
5359     unimplemented!("Unsupported target OS");
5360 }
5361 #[cfg(feature = "Win32_System_Com")]
5362 #[inline]
NdrFixedArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5363 pub unsafe fn NdrFixedArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5364     #[cfg(windows)]
5365     {
5366         #[link(name = "windows")]
5367         extern "system" {
5368             fn NdrFixedArrayBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5369         }
5370         ::std::mem::transmute(NdrFixedArrayBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5371     }
5372     #[cfg(not(windows))]
5373     unimplemented!("Unsupported target OS");
5374 }
5375 #[cfg(feature = "Win32_System_Com")]
5376 #[inline]
NdrFixedArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5377 pub unsafe fn NdrFixedArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5378     #[cfg(windows)]
5379     {
5380         #[link(name = "windows")]
5381         extern "system" {
5382             fn NdrFixedArrayFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5383         }
5384         ::std::mem::transmute(NdrFixedArrayFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5385     }
5386     #[cfg(not(windows))]
5387     unimplemented!("Unsupported target OS");
5388 }
5389 #[cfg(feature = "Win32_System_Com")]
5390 #[inline]
NdrFixedArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85391 pub unsafe fn NdrFixedArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5392     #[cfg(windows)]
5393     {
5394         #[link(name = "windows")]
5395         extern "system" {
5396             fn NdrFixedArrayMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5397         }
5398         ::std::mem::transmute(NdrFixedArrayMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5399     }
5400     #[cfg(not(windows))]
5401     unimplemented!("Unsupported target OS");
5402 }
5403 #[cfg(feature = "Win32_System_Com")]
5404 #[inline]
NdrFixedArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325405 pub unsafe fn NdrFixedArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5406     #[cfg(windows)]
5407     {
5408         #[link(name = "windows")]
5409         extern "system" {
5410             fn NdrFixedArrayMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5411         }
5412         ::std::mem::transmute(NdrFixedArrayMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5413     }
5414     #[cfg(not(windows))]
5415     unimplemented!("Unsupported target OS");
5416 }
5417 #[cfg(feature = "Win32_System_Com")]
5418 #[inline]
NdrFixedArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85419 pub unsafe fn NdrFixedArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5420     #[cfg(windows)]
5421     {
5422         #[link(name = "windows")]
5423         extern "system" {
5424             fn NdrFixedArrayUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5425         }
5426         ::std::mem::transmute(NdrFixedArrayUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5427     }
5428     #[cfg(not(windows))]
5429     unimplemented!("Unsupported target OS");
5430 }
5431 #[cfg(feature = "Win32_System_Com")]
5432 #[inline]
NdrFreeBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE)5433 pub unsafe fn NdrFreeBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE) {
5434     #[cfg(windows)]
5435     {
5436         #[link(name = "windows")]
5437         extern "system" {
5438             fn NdrFreeBuffer(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
5439         }
5440         ::std::mem::transmute(NdrFreeBuffer(::std::mem::transmute(pstubmsg)))
5441     }
5442     #[cfg(not(windows))]
5443     unimplemented!("Unsupported target OS");
5444 }
5445 #[inline]
NdrFullPointerXlatFree(pxlattables: *mut FULL_PTR_XLAT_TABLES)5446 pub unsafe fn NdrFullPointerXlatFree(pxlattables: *mut FULL_PTR_XLAT_TABLES) {
5447     #[cfg(windows)]
5448     {
5449         #[link(name = "windows")]
5450         extern "system" {
5451             fn NdrFullPointerXlatFree(pxlattables: *mut FULL_PTR_XLAT_TABLES);
5452         }
5453         ::std::mem::transmute(NdrFullPointerXlatFree(::std::mem::transmute(pxlattables)))
5454     }
5455     #[cfg(not(windows))]
5456     unimplemented!("Unsupported target OS");
5457 }
5458 #[inline]
NdrFullPointerXlatInit(numberofpointers: u32, xlatside: XLAT_SIDE) -> *mut FULL_PTR_XLAT_TABLES5459 pub unsafe fn NdrFullPointerXlatInit(numberofpointers: u32, xlatside: XLAT_SIDE) -> *mut FULL_PTR_XLAT_TABLES {
5460     #[cfg(windows)]
5461     {
5462         #[link(name = "windows")]
5463         extern "system" {
5464             fn NdrFullPointerXlatInit(numberofpointers: u32, xlatside: XLAT_SIDE) -> *mut FULL_PTR_XLAT_TABLES;
5465         }
5466         ::std::mem::transmute(NdrFullPointerXlatInit(::std::mem::transmute(numberofpointers), ::std::mem::transmute(xlatside)))
5467     }
5468     #[cfg(not(windows))]
5469     unimplemented!("Unsupported target OS");
5470 }
5471 #[cfg(feature = "Win32_System_Com")]
5472 #[inline]
NdrGetBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u85473 pub unsafe fn NdrGetBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u8 {
5474     #[cfg(windows)]
5475     {
5476         #[link(name = "windows")]
5477         extern "system" {
5478             fn NdrGetBuffer(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u8;
5479         }
5480         ::std::mem::transmute(NdrGetBuffer(::std::mem::transmute(pstubmsg), ::std::mem::transmute(bufferlength), ::std::mem::transmute(handle)))
5481     }
5482     #[cfg(not(windows))]
5483     unimplemented!("Unsupported target OS");
5484 }
5485 #[cfg(feature = "Win32_System_Com")]
5486 #[inline]
NdrGetDcomProtocolVersion(pstubmsg: *mut MIDL_STUB_MESSAGE, pversion: *mut RPC_VERSION) -> ::windows::runtime::Result<()>5487 pub unsafe fn NdrGetDcomProtocolVersion(pstubmsg: *mut MIDL_STUB_MESSAGE, pversion: *mut RPC_VERSION) -> ::windows::runtime::Result<()> {
5488     #[cfg(windows)]
5489     {
5490         #[link(name = "windows")]
5491         extern "system" {
5492             fn NdrGetDcomProtocolVersion(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pversion: *mut RPC_VERSION) -> ::windows::runtime::HRESULT;
5493         }
5494         NdrGetDcomProtocolVersion(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pversion)).ok()
5495     }
5496     #[cfg(not(windows))]
5497     unimplemented!("Unsupported target OS");
5498 }
5499 #[cfg(feature = "Win32_System_Com")]
5500 #[inline]
NdrGetUserMarshalInfo(pflags: *const u32, informationlevel: u32, pmarshalinfo: *mut NDR_USER_MARSHAL_INFO) -> RPC_STATUS5501 pub unsafe fn NdrGetUserMarshalInfo(pflags: *const u32, informationlevel: u32, pmarshalinfo: *mut NDR_USER_MARSHAL_INFO) -> RPC_STATUS {
5502     #[cfg(windows)]
5503     {
5504         #[link(name = "windows")]
5505         extern "system" {
5506             fn NdrGetUserMarshalInfo(pflags: *const u32, informationlevel: u32, pmarshalinfo: *mut ::std::mem::ManuallyDrop<NDR_USER_MARSHAL_INFO>) -> RPC_STATUS;
5507         }
5508         ::std::mem::transmute(NdrGetUserMarshalInfo(::std::mem::transmute(pflags), ::std::mem::transmute(informationlevel), ::std::mem::transmute(pmarshalinfo)))
5509     }
5510     #[cfg(not(windows))]
5511     unimplemented!("Unsupported target OS");
5512 }
5513 #[cfg(feature = "Win32_System_Com")]
5514 #[inline]
NdrInterfacePointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5515 pub unsafe fn NdrInterfacePointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5516     #[cfg(windows)]
5517     {
5518         #[link(name = "windows")]
5519         extern "system" {
5520             fn NdrInterfacePointerBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5521         }
5522         ::std::mem::transmute(NdrInterfacePointerBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5523     }
5524     #[cfg(not(windows))]
5525     unimplemented!("Unsupported target OS");
5526 }
5527 #[cfg(feature = "Win32_System_Com")]
5528 #[inline]
NdrInterfacePointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5529 pub unsafe fn NdrInterfacePointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5530     #[cfg(windows)]
5531     {
5532         #[link(name = "windows")]
5533         extern "system" {
5534             fn NdrInterfacePointerFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5535         }
5536         ::std::mem::transmute(NdrInterfacePointerFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5537     }
5538     #[cfg(not(windows))]
5539     unimplemented!("Unsupported target OS");
5540 }
5541 #[cfg(feature = "Win32_System_Com")]
5542 #[inline]
NdrInterfacePointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85543 pub unsafe fn NdrInterfacePointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5544     #[cfg(windows)]
5545     {
5546         #[link(name = "windows")]
5547         extern "system" {
5548             fn NdrInterfacePointerMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5549         }
5550         ::std::mem::transmute(NdrInterfacePointerMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5551     }
5552     #[cfg(not(windows))]
5553     unimplemented!("Unsupported target OS");
5554 }
5555 #[cfg(feature = "Win32_System_Com")]
5556 #[inline]
NdrInterfacePointerMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325557 pub unsafe fn NdrInterfacePointerMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5558     #[cfg(windows)]
5559     {
5560         #[link(name = "windows")]
5561         extern "system" {
5562             fn NdrInterfacePointerMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5563         }
5564         ::std::mem::transmute(NdrInterfacePointerMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5565     }
5566     #[cfg(not(windows))]
5567     unimplemented!("Unsupported target OS");
5568 }
5569 #[cfg(feature = "Win32_System_Com")]
5570 #[inline]
NdrInterfacePointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85571 pub unsafe fn NdrInterfacePointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5572     #[cfg(windows)]
5573     {
5574         #[link(name = "windows")]
5575         extern "system" {
5576             fn NdrInterfacePointerUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5577         }
5578         ::std::mem::transmute(NdrInterfacePointerUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5579     }
5580     #[cfg(not(windows))]
5581     unimplemented!("Unsupported target OS");
5582 }
5583 #[cfg(feature = "Win32_System_Com")]
5584 #[inline]
NdrMapCommAndFaultStatus(pstubmsg: *mut MIDL_STUB_MESSAGE, pcommstatus: *mut u32, pfaultstatus: *mut u32, status: RPC_STATUS) -> RPC_STATUS5585 pub unsafe fn NdrMapCommAndFaultStatus(pstubmsg: *mut MIDL_STUB_MESSAGE, pcommstatus: *mut u32, pfaultstatus: *mut u32, status: RPC_STATUS) -> RPC_STATUS {
5586     #[cfg(windows)]
5587     {
5588         #[link(name = "windows")]
5589         extern "system" {
5590             fn NdrMapCommAndFaultStatus(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pcommstatus: *mut u32, pfaultstatus: *mut u32, status: RPC_STATUS) -> RPC_STATUS;
5591         }
5592         ::std::mem::transmute(NdrMapCommAndFaultStatus(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pcommstatus), ::std::mem::transmute(pfaultstatus), ::std::mem::transmute(status)))
5593     }
5594     #[cfg(not(windows))]
5595     unimplemented!("Unsupported target OS");
5596 }
5597 #[cfg(feature = "Win32_System_Com")]
5598 #[inline]
NdrMesProcEncodeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8)5599 pub unsafe fn NdrMesProcEncodeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8) {
5600     #[cfg(windows)]
5601     {
5602         #[link(name = "windows")]
5603         extern "system" {
5604             fn NdrMesProcEncodeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8);
5605         }
5606         ::std::mem::transmute(NdrMesProcEncodeDecode(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring)))
5607     }
5608     #[cfg(not(windows))]
5609     unimplemented!("Unsupported target OS");
5610 }
5611 #[cfg(feature = "Win32_System_Com")]
5612 #[inline]
NdrMesProcEncodeDecode2(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8) -> CLIENT_CALL_RETURN5613 pub unsafe fn NdrMesProcEncodeDecode2(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8) -> CLIENT_CALL_RETURN {
5614     #[cfg(windows)]
5615     {
5616         #[link(name = "windows")]
5617         extern "system" {
5618             fn NdrMesProcEncodeDecode2(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8) -> CLIENT_CALL_RETURN;
5619         }
5620         ::std::mem::transmute(NdrMesProcEncodeDecode2(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring)))
5621     }
5622     #[cfg(not(windows))]
5623     unimplemented!("Unsupported target OS");
5624 }
5625 #[cfg(feature = "Win32_System_Com")]
5626 #[inline]
NdrMesProcEncodeDecode3(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN5627 pub unsafe fn NdrMesProcEncodeDecode3(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN {
5628     #[cfg(windows)]
5629     {
5630         #[link(name = "windows")]
5631         extern "system" {
5632             fn NdrMesProcEncodeDecode3(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, nprocnum: u32, preturnvalue: *mut ::std::ffi::c_void) -> CLIENT_CALL_RETURN;
5633         }
5634         ::std::mem::transmute(NdrMesProcEncodeDecode3(::std::mem::transmute(handle), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(nprocnum), ::std::mem::transmute(preturnvalue)))
5635     }
5636     #[cfg(not(windows))]
5637     unimplemented!("Unsupported target OS");
5638 }
5639 #[inline]
NdrMesSimpleTypeAlignSize(param0: *mut ::std::ffi::c_void) -> usize5640 pub unsafe fn NdrMesSimpleTypeAlignSize(param0: *mut ::std::ffi::c_void) -> usize {
5641     #[cfg(windows)]
5642     {
5643         #[link(name = "windows")]
5644         extern "system" {
5645             fn NdrMesSimpleTypeAlignSize(param0: *mut ::std::ffi::c_void) -> usize;
5646         }
5647         ::std::mem::transmute(NdrMesSimpleTypeAlignSize(::std::mem::transmute(param0)))
5648     }
5649     #[cfg(not(windows))]
5650     unimplemented!("Unsupported target OS");
5651 }
5652 #[cfg(feature = "Win32_System_Com")]
5653 #[inline]
NdrMesSimpleTypeAlignSizeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO) -> usize5654 pub unsafe fn NdrMesSimpleTypeAlignSizeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO) -> usize {
5655     #[cfg(windows)]
5656     {
5657         #[link(name = "windows")]
5658         extern "system" {
5659             fn NdrMesSimpleTypeAlignSizeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO) -> usize;
5660         }
5661         ::std::mem::transmute(NdrMesSimpleTypeAlignSizeAll(::std::mem::transmute(handle), ::std::mem::transmute(pproxyinfo)))
5662     }
5663     #[cfg(not(windows))]
5664     unimplemented!("Unsupported target OS");
5665 }
5666 #[inline]
NdrMesSimpleTypeDecode(handle: *mut ::std::ffi::c_void, pobject: *mut ::std::ffi::c_void, size: i16)5667 pub unsafe fn NdrMesSimpleTypeDecode(handle: *mut ::std::ffi::c_void, pobject: *mut ::std::ffi::c_void, size: i16) {
5668     #[cfg(windows)]
5669     {
5670         #[link(name = "windows")]
5671         extern "system" {
5672             fn NdrMesSimpleTypeDecode(handle: *mut ::std::ffi::c_void, pobject: *mut ::std::ffi::c_void, size: i16);
5673         }
5674         ::std::mem::transmute(NdrMesSimpleTypeDecode(::std::mem::transmute(handle), ::std::mem::transmute(pobject), ::std::mem::transmute(size)))
5675     }
5676     #[cfg(not(windows))]
5677     unimplemented!("Unsupported target OS");
5678 }
5679 #[cfg(feature = "Win32_System_Com")]
5680 #[inline]
NdrMesSimpleTypeDecodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *mut ::std::ffi::c_void, size: i16)5681 pub unsafe fn NdrMesSimpleTypeDecodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *mut ::std::ffi::c_void, size: i16) {
5682     #[cfg(windows)]
5683     {
5684         #[link(name = "windows")]
5685         extern "system" {
5686             fn NdrMesSimpleTypeDecodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *mut ::std::ffi::c_void, size: i16);
5687         }
5688         ::std::mem::transmute(NdrMesSimpleTypeDecodeAll(::std::mem::transmute(handle), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(pobject), ::std::mem::transmute(size)))
5689     }
5690     #[cfg(not(windows))]
5691     unimplemented!("Unsupported target OS");
5692 }
5693 #[cfg(feature = "Win32_System_Com")]
5694 #[inline]
NdrMesSimpleTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pobject: *const ::std::ffi::c_void, size: i16)5695 pub unsafe fn NdrMesSimpleTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pobject: *const ::std::ffi::c_void, size: i16) {
5696     #[cfg(windows)]
5697     {
5698         #[link(name = "windows")]
5699         extern "system" {
5700             fn NdrMesSimpleTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pobject: *const ::std::ffi::c_void, size: i16);
5701         }
5702         ::std::mem::transmute(NdrMesSimpleTypeEncode(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pobject), ::std::mem::transmute(size)))
5703     }
5704     #[cfg(not(windows))]
5705     unimplemented!("Unsupported target OS");
5706 }
5707 #[cfg(feature = "Win32_System_Com")]
5708 #[inline]
NdrMesSimpleTypeEncodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *const ::std::ffi::c_void, size: i16)5709 pub unsafe fn NdrMesSimpleTypeEncodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *const ::std::ffi::c_void, size: i16) {
5710     #[cfg(windows)]
5711     {
5712         #[link(name = "windows")]
5713         extern "system" {
5714             fn NdrMesSimpleTypeEncodeAll(handle: *mut ::std::ffi::c_void, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, pobject: *const ::std::ffi::c_void, size: i16);
5715         }
5716         ::std::mem::transmute(NdrMesSimpleTypeEncodeAll(::std::mem::transmute(handle), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(pobject), ::std::mem::transmute(size)))
5717     }
5718     #[cfg(not(windows))]
5719     unimplemented!("Unsupported target OS");
5720 }
5721 #[cfg(feature = "Win32_System_Com")]
5722 #[inline]
NdrMesTypeAlignSize(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize5723 pub unsafe fn NdrMesTypeAlignSize(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize {
5724     #[cfg(windows)]
5725     {
5726         #[link(name = "windows")]
5727         extern "system" {
5728             fn NdrMesTypeAlignSize(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize;
5729         }
5730         ::std::mem::transmute(NdrMesTypeAlignSize(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5731     }
5732     #[cfg(not(windows))]
5733     unimplemented!("Unsupported target OS");
5734 }
5735 #[cfg(feature = "Win32_System_Com")]
5736 #[inline]
NdrMesTypeAlignSize2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize5737 pub unsafe fn NdrMesTypeAlignSize2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize {
5738     #[cfg(windows)]
5739     {
5740         #[link(name = "windows")]
5741         extern "system" {
5742             fn NdrMesTypeAlignSize2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) -> usize;
5743         }
5744         ::std::mem::transmute(NdrMesTypeAlignSize2(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5745     }
5746     #[cfg(not(windows))]
5747     unimplemented!("Unsupported target OS");
5748 }
5749 #[cfg(feature = "Win32_System_Com")]
5750 #[inline]
NdrMesTypeAlignSize3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void) -> usize5751 pub unsafe fn NdrMesTypeAlignSize3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void) -> usize {
5752     #[cfg(windows)]
5753     {
5754         #[link(name = "windows")]
5755         extern "system" {
5756             fn NdrMesTypeAlignSize3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void) -> usize;
5757         }
5758         ::std::mem::transmute(NdrMesTypeAlignSize3(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(arrtypeoffset), ::std::mem::transmute(ntypeindex), ::std::mem::transmute(pobject)))
5759     }
5760     #[cfg(not(windows))]
5761     unimplemented!("Unsupported target OS");
5762 }
5763 #[cfg(feature = "Win32_System_Com")]
5764 #[inline]
NdrMesTypeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void)5765 pub unsafe fn NdrMesTypeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void) {
5766     #[cfg(windows)]
5767     {
5768         #[link(name = "windows")]
5769         extern "system" {
5770             fn NdrMesTypeDecode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void);
5771         }
5772         ::std::mem::transmute(NdrMesTypeDecode(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5773     }
5774     #[cfg(not(windows))]
5775     unimplemented!("Unsupported target OS");
5776 }
5777 #[cfg(feature = "Win32_System_Com")]
5778 #[inline]
NdrMesTypeDecode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void)5779 pub unsafe fn NdrMesTypeDecode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void) {
5780     #[cfg(windows)]
5781     {
5782         #[link(name = "windows")]
5783         extern "system" {
5784             fn NdrMesTypeDecode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void);
5785         }
5786         ::std::mem::transmute(NdrMesTypeDecode2(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5787     }
5788     #[cfg(not(windows))]
5789     unimplemented!("Unsupported target OS");
5790 }
5791 #[cfg(feature = "Win32_System_Com")]
5792 #[inline]
NdrMesTypeDecode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void)5793 pub unsafe fn NdrMesTypeDecode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void) {
5794     #[cfg(windows)]
5795     {
5796         #[link(name = "windows")]
5797         extern "system" {
5798             fn NdrMesTypeDecode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void);
5799         }
5800         ::std::mem::transmute(NdrMesTypeDecode3(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(arrtypeoffset), ::std::mem::transmute(ntypeindex), ::std::mem::transmute(pobject)))
5801     }
5802     #[cfg(not(windows))]
5803     unimplemented!("Unsupported target OS");
5804 }
5805 #[cfg(feature = "Win32_System_Com")]
5806 #[inline]
NdrMesTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void)5807 pub unsafe fn NdrMesTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) {
5808     #[cfg(windows)]
5809     {
5810         #[link(name = "windows")]
5811         extern "system" {
5812             fn NdrMesTypeEncode(handle: *mut ::std::ffi::c_void, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void);
5813         }
5814         ::std::mem::transmute(NdrMesTypeEncode(::std::mem::transmute(handle), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5815     }
5816     #[cfg(not(windows))]
5817     unimplemented!("Unsupported target OS");
5818 }
5819 #[cfg(feature = "Win32_System_Com")]
5820 #[inline]
NdrMesTypeEncode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void)5821 pub unsafe fn NdrMesTypeEncode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void) {
5822     #[cfg(windows)]
5823     {
5824         #[link(name = "windows")]
5825         extern "system" {
5826             fn NdrMesTypeEncode2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *const ::std::ffi::c_void);
5827         }
5828         ::std::mem::transmute(NdrMesTypeEncode2(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5829     }
5830     #[cfg(not(windows))]
5831     unimplemented!("Unsupported target OS");
5832 }
5833 #[cfg(feature = "Win32_System_Com")]
5834 #[inline]
NdrMesTypeEncode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void)5835 pub unsafe fn NdrMesTypeEncode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void) {
5836     #[cfg(windows)]
5837     {
5838         #[link(name = "windows")]
5839         extern "system" {
5840             fn NdrMesTypeEncode3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *const ::std::ffi::c_void);
5841         }
5842         ::std::mem::transmute(NdrMesTypeEncode3(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(arrtypeoffset), ::std::mem::transmute(ntypeindex), ::std::mem::transmute(pobject)))
5843     }
5844     #[cfg(not(windows))]
5845     unimplemented!("Unsupported target OS");
5846 }
5847 #[cfg(feature = "Win32_System_Com")]
5848 #[inline]
NdrMesTypeFree2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void)5849 pub unsafe fn NdrMesTypeFree2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void) {
5850     #[cfg(windows)]
5851     {
5852         #[link(name = "windows")]
5853         extern "system" {
5854             fn NdrMesTypeFree2(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pstubdesc: *const MIDL_STUB_DESC, pformatstring: *mut u8, pobject: *mut ::std::ffi::c_void);
5855         }
5856         ::std::mem::transmute(NdrMesTypeFree2(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pstubdesc), ::std::mem::transmute(pformatstring), ::std::mem::transmute(pobject)))
5857     }
5858     #[cfg(not(windows))]
5859     unimplemented!("Unsupported target OS");
5860 }
5861 #[cfg(feature = "Win32_System_Com")]
5862 #[inline]
NdrMesTypeFree3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void)5863 pub unsafe fn NdrMesTypeFree3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void) {
5864     #[cfg(windows)]
5865     {
5866         #[link(name = "windows")]
5867         extern "system" {
5868             fn NdrMesTypeFree3(handle: *mut ::std::ffi::c_void, ppicklinginfo: *const MIDL_TYPE_PICKLING_INFO, pproxyinfo: *const MIDL_STUBLESS_PROXY_INFO, arrtypeoffset: *const *const u32, ntypeindex: u32, pobject: *mut ::std::ffi::c_void);
5869         }
5870         ::std::mem::transmute(NdrMesTypeFree3(::std::mem::transmute(handle), ::std::mem::transmute(ppicklinginfo), ::std::mem::transmute(pproxyinfo), ::std::mem::transmute(arrtypeoffset), ::std::mem::transmute(ntypeindex), ::std::mem::transmute(pobject)))
5871     }
5872     #[cfg(not(windows))]
5873     unimplemented!("Unsupported target OS");
5874 }
5875 #[cfg(feature = "Win32_System_Com")]
5876 #[inline]
NdrNonConformantStringBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5877 pub unsafe fn NdrNonConformantStringBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5878     #[cfg(windows)]
5879     {
5880         #[link(name = "windows")]
5881         extern "system" {
5882             fn NdrNonConformantStringBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5883         }
5884         ::std::mem::transmute(NdrNonConformantStringBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5885     }
5886     #[cfg(not(windows))]
5887     unimplemented!("Unsupported target OS");
5888 }
5889 #[cfg(feature = "Win32_System_Com")]
5890 #[inline]
NdrNonConformantStringMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85891 pub unsafe fn NdrNonConformantStringMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5892     #[cfg(windows)]
5893     {
5894         #[link(name = "windows")]
5895         extern "system" {
5896             fn NdrNonConformantStringMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5897         }
5898         ::std::mem::transmute(NdrNonConformantStringMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5899     }
5900     #[cfg(not(windows))]
5901     unimplemented!("Unsupported target OS");
5902 }
5903 #[cfg(feature = "Win32_System_Com")]
5904 #[inline]
NdrNonConformantStringMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325905 pub unsafe fn NdrNonConformantStringMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5906     #[cfg(windows)]
5907     {
5908         #[link(name = "windows")]
5909         extern "system" {
5910             fn NdrNonConformantStringMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5911         }
5912         ::std::mem::transmute(NdrNonConformantStringMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5913     }
5914     #[cfg(not(windows))]
5915     unimplemented!("Unsupported target OS");
5916 }
5917 #[cfg(feature = "Win32_System_Com")]
5918 #[inline]
NdrNonConformantStringUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85919 pub unsafe fn NdrNonConformantStringUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5920     #[cfg(windows)]
5921     {
5922         #[link(name = "windows")]
5923         extern "system" {
5924             fn NdrNonConformantStringUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5925         }
5926         ::std::mem::transmute(NdrNonConformantStringUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5927     }
5928     #[cfg(not(windows))]
5929     unimplemented!("Unsupported target OS");
5930 }
5931 #[cfg(feature = "Win32_System_Com")]
5932 #[inline]
NdrNonEncapsulatedUnionBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5933 pub unsafe fn NdrNonEncapsulatedUnionBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5934     #[cfg(windows)]
5935     {
5936         #[link(name = "windows")]
5937         extern "system" {
5938             fn NdrNonEncapsulatedUnionBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5939         }
5940         ::std::mem::transmute(NdrNonEncapsulatedUnionBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5941     }
5942     #[cfg(not(windows))]
5943     unimplemented!("Unsupported target OS");
5944 }
5945 #[cfg(feature = "Win32_System_Com")]
5946 #[inline]
NdrNonEncapsulatedUnionFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)5947 pub unsafe fn NdrNonEncapsulatedUnionFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
5948     #[cfg(windows)]
5949     {
5950         #[link(name = "windows")]
5951         extern "system" {
5952             fn NdrNonEncapsulatedUnionFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
5953         }
5954         ::std::mem::transmute(NdrNonEncapsulatedUnionFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5955     }
5956     #[cfg(not(windows))]
5957     unimplemented!("Unsupported target OS");
5958 }
5959 #[cfg(feature = "Win32_System_Com")]
5960 #[inline]
NdrNonEncapsulatedUnionMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u85961 pub unsafe fn NdrNonEncapsulatedUnionMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
5962     #[cfg(windows)]
5963     {
5964         #[link(name = "windows")]
5965         extern "system" {
5966             fn NdrNonEncapsulatedUnionMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
5967         }
5968         ::std::mem::transmute(NdrNonEncapsulatedUnionMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
5969     }
5970     #[cfg(not(windows))]
5971     unimplemented!("Unsupported target OS");
5972 }
5973 #[cfg(feature = "Win32_System_Com")]
5974 #[inline]
NdrNonEncapsulatedUnionMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u325975 pub unsafe fn NdrNonEncapsulatedUnionMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
5976     #[cfg(windows)]
5977     {
5978         #[link(name = "windows")]
5979         extern "system" {
5980             fn NdrNonEncapsulatedUnionMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
5981         }
5982         ::std::mem::transmute(NdrNonEncapsulatedUnionMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
5983     }
5984     #[cfg(not(windows))]
5985     unimplemented!("Unsupported target OS");
5986 }
5987 #[cfg(feature = "Win32_System_Com")]
5988 #[inline]
NdrNonEncapsulatedUnionUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u85989 pub unsafe fn NdrNonEncapsulatedUnionUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
5990     #[cfg(windows)]
5991     {
5992         #[link(name = "windows")]
5993         extern "system" {
5994             fn NdrNonEncapsulatedUnionUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
5995         }
5996         ::std::mem::transmute(NdrNonEncapsulatedUnionUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
5997     }
5998     #[cfg(not(windows))]
5999     unimplemented!("Unsupported target OS");
6000 }
6001 #[cfg(feature = "Win32_System_Com")]
6002 #[inline]
NdrNsGetBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u86003 pub unsafe fn NdrNsGetBuffer(pstubmsg: *mut MIDL_STUB_MESSAGE, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u8 {
6004     #[cfg(windows)]
6005     {
6006         #[link(name = "windows")]
6007         extern "system" {
6008             fn NdrNsGetBuffer(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, bufferlength: u32, handle: *mut ::std::ffi::c_void) -> *mut u8;
6009         }
6010         ::std::mem::transmute(NdrNsGetBuffer(::std::mem::transmute(pstubmsg), ::std::mem::transmute(bufferlength), ::std::mem::transmute(handle)))
6011     }
6012     #[cfg(not(windows))]
6013     unimplemented!("Unsupported target OS");
6014 }
6015 #[cfg(feature = "Win32_System_Com")]
6016 #[inline]
NdrNsSendReceive(pstubmsg: *mut MIDL_STUB_MESSAGE, pbufferend: *mut u8, pautohandle: *mut *mut ::std::ffi::c_void) -> *mut u86017 pub unsafe fn NdrNsSendReceive(pstubmsg: *mut MIDL_STUB_MESSAGE, pbufferend: *mut u8, pautohandle: *mut *mut ::std::ffi::c_void) -> *mut u8 {
6018     #[cfg(windows)]
6019     {
6020         #[link(name = "windows")]
6021         extern "system" {
6022             fn NdrNsSendReceive(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pbufferend: *mut u8, pautohandle: *mut *mut ::std::ffi::c_void) -> *mut u8;
6023         }
6024         ::std::mem::transmute(NdrNsSendReceive(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pbufferend), ::std::mem::transmute(pautohandle)))
6025     }
6026     #[cfg(not(windows))]
6027     unimplemented!("Unsupported target OS");
6028 }
6029 #[inline]
NdrOleAllocate(size: usize) -> *mut ::std::ffi::c_void6030 pub unsafe fn NdrOleAllocate(size: usize) -> *mut ::std::ffi::c_void {
6031     #[cfg(windows)]
6032     {
6033         #[link(name = "windows")]
6034         extern "system" {
6035             fn NdrOleAllocate(size: usize) -> *mut ::std::ffi::c_void;
6036         }
6037         ::std::mem::transmute(NdrOleAllocate(::std::mem::transmute(size)))
6038     }
6039     #[cfg(not(windows))]
6040     unimplemented!("Unsupported target OS");
6041 }
6042 #[inline]
NdrOleFree(nodetofree: *const ::std::ffi::c_void)6043 pub unsafe fn NdrOleFree(nodetofree: *const ::std::ffi::c_void) {
6044     #[cfg(windows)]
6045     {
6046         #[link(name = "windows")]
6047         extern "system" {
6048             fn NdrOleFree(nodetofree: *const ::std::ffi::c_void);
6049         }
6050         ::std::mem::transmute(NdrOleFree(::std::mem::transmute(nodetofree)))
6051     }
6052     #[cfg(not(windows))]
6053     unimplemented!("Unsupported target OS");
6054 }
6055 #[cfg(feature = "Win32_System_Com")]
6056 #[inline]
NdrPartialIgnoreClientBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void)6057 pub unsafe fn NdrPartialIgnoreClientBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void) {
6058     #[cfg(windows)]
6059     {
6060         #[link(name = "windows")]
6061         extern "system" {
6062             fn NdrPartialIgnoreClientBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut ::std::ffi::c_void);
6063         }
6064         ::std::mem::transmute(NdrPartialIgnoreClientBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory)))
6065     }
6066     #[cfg(not(windows))]
6067     unimplemented!("Unsupported target OS");
6068 }
6069 #[cfg(feature = "Win32_System_Com")]
6070 #[inline]
NdrPartialIgnoreClientMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void)6071 pub unsafe fn NdrPartialIgnoreClientMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut ::std::ffi::c_void) {
6072     #[cfg(windows)]
6073     {
6074         #[link(name = "windows")]
6075         extern "system" {
6076             fn NdrPartialIgnoreClientMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut ::std::ffi::c_void);
6077         }
6078         ::std::mem::transmute(NdrPartialIgnoreClientMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory)))
6079     }
6080     #[cfg(not(windows))]
6081     unimplemented!("Unsupported target OS");
6082 }
6083 #[cfg(feature = "Win32_System_Com")]
6084 #[inline]
NdrPartialIgnoreServerInitialize(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut ::std::ffi::c_void, pformat: *mut u8)6085 pub unsafe fn NdrPartialIgnoreServerInitialize(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut ::std::ffi::c_void, pformat: *mut u8) {
6086     #[cfg(windows)]
6087     {
6088         #[link(name = "windows")]
6089         extern "system" {
6090             fn NdrPartialIgnoreServerInitialize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut ::std::ffi::c_void, pformat: *mut u8);
6091         }
6092         ::std::mem::transmute(NdrPartialIgnoreServerInitialize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat)))
6093     }
6094     #[cfg(not(windows))]
6095     unimplemented!("Unsupported target OS");
6096 }
6097 #[cfg(feature = "Win32_System_Com")]
6098 #[inline]
NdrPartialIgnoreServerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut ::std::ffi::c_void)6099 pub unsafe fn NdrPartialIgnoreServerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut ::std::ffi::c_void) {
6100     #[cfg(windows)]
6101     {
6102         #[link(name = "windows")]
6103         extern "system" {
6104             fn NdrPartialIgnoreServerUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut ::std::ffi::c_void);
6105         }
6106         ::std::mem::transmute(NdrPartialIgnoreServerUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory)))
6107     }
6108     #[cfg(not(windows))]
6109     unimplemented!("Unsupported target OS");
6110 }
6111 #[cfg(feature = "Win32_System_Com")]
6112 #[inline]
NdrPointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6113 pub unsafe fn NdrPointerBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6114     #[cfg(windows)]
6115     {
6116         #[link(name = "windows")]
6117         extern "system" {
6118             fn NdrPointerBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6119         }
6120         ::std::mem::transmute(NdrPointerBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6121     }
6122     #[cfg(not(windows))]
6123     unimplemented!("Unsupported target OS");
6124 }
6125 #[cfg(feature = "Win32_System_Com")]
6126 #[inline]
NdrPointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6127 pub unsafe fn NdrPointerFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6128     #[cfg(windows)]
6129     {
6130         #[link(name = "windows")]
6131         extern "system" {
6132             fn NdrPointerFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6133         }
6134         ::std::mem::transmute(NdrPointerFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6135     }
6136     #[cfg(not(windows))]
6137     unimplemented!("Unsupported target OS");
6138 }
6139 #[cfg(feature = "Win32_System_Com")]
6140 #[inline]
NdrPointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u86141 pub unsafe fn NdrPointerMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
6142     #[cfg(windows)]
6143     {
6144         #[link(name = "windows")]
6145         extern "system" {
6146             fn NdrPointerMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
6147         }
6148         ::std::mem::transmute(NdrPointerMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6149     }
6150     #[cfg(not(windows))]
6151     unimplemented!("Unsupported target OS");
6152 }
6153 #[cfg(feature = "Win32_System_Com")]
6154 #[inline]
NdrPointerMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u326155 pub unsafe fn NdrPointerMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
6156     #[cfg(windows)]
6157     {
6158         #[link(name = "windows")]
6159         extern "system" {
6160             fn NdrPointerMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
6161         }
6162         ::std::mem::transmute(NdrPointerMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6163     }
6164     #[cfg(not(windows))]
6165     unimplemented!("Unsupported target OS");
6166 }
6167 #[cfg(feature = "Win32_System_Com")]
6168 #[inline]
NdrPointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86169 pub unsafe fn NdrPointerUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6170     #[cfg(windows)]
6171     {
6172         #[link(name = "windows")]
6173         extern "system" {
6174             fn NdrPointerUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6175         }
6176         ::std::mem::transmute(NdrPointerUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6177     }
6178     #[cfg(not(windows))]
6179     unimplemented!("Unsupported target OS");
6180 }
6181 #[cfg(feature = "Win32_System_Com")]
6182 #[inline]
NdrRangeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86183 pub unsafe fn NdrRangeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6184     #[cfg(windows)]
6185     {
6186         #[link(name = "windows")]
6187         extern "system" {
6188             fn NdrRangeUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6189         }
6190         ::std::mem::transmute(NdrRangeUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6191     }
6192     #[cfg(not(windows))]
6193     unimplemented!("Unsupported target OS");
6194 }
6195 #[inline]
NdrRpcSmClientAllocate(size: usize) -> *mut ::std::ffi::c_void6196 pub unsafe fn NdrRpcSmClientAllocate(size: usize) -> *mut ::std::ffi::c_void {
6197     #[cfg(windows)]
6198     {
6199         #[link(name = "windows")]
6200         extern "system" {
6201             fn NdrRpcSmClientAllocate(size: usize) -> *mut ::std::ffi::c_void;
6202         }
6203         ::std::mem::transmute(NdrRpcSmClientAllocate(::std::mem::transmute(size)))
6204     }
6205     #[cfg(not(windows))]
6206     unimplemented!("Unsupported target OS");
6207 }
6208 #[inline]
NdrRpcSmClientFree(nodetofree: *const ::std::ffi::c_void)6209 pub unsafe fn NdrRpcSmClientFree(nodetofree: *const ::std::ffi::c_void) {
6210     #[cfg(windows)]
6211     {
6212         #[link(name = "windows")]
6213         extern "system" {
6214             fn NdrRpcSmClientFree(nodetofree: *const ::std::ffi::c_void);
6215         }
6216         ::std::mem::transmute(NdrRpcSmClientFree(::std::mem::transmute(nodetofree)))
6217     }
6218     #[cfg(not(windows))]
6219     unimplemented!("Unsupported target OS");
6220 }
6221 #[cfg(feature = "Win32_System_Com")]
6222 #[inline]
NdrRpcSmSetClientToOsf(pmessage: *mut MIDL_STUB_MESSAGE)6223 pub unsafe fn NdrRpcSmSetClientToOsf(pmessage: *mut MIDL_STUB_MESSAGE) {
6224     #[cfg(windows)]
6225     {
6226         #[link(name = "windows")]
6227         extern "system" {
6228             fn NdrRpcSmSetClientToOsf(pmessage: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
6229         }
6230         ::std::mem::transmute(NdrRpcSmSetClientToOsf(::std::mem::transmute(pmessage)))
6231     }
6232     #[cfg(not(windows))]
6233     unimplemented!("Unsupported target OS");
6234 }
6235 #[inline]
NdrRpcSsDefaultAllocate(size: usize) -> *mut ::std::ffi::c_void6236 pub unsafe fn NdrRpcSsDefaultAllocate(size: usize) -> *mut ::std::ffi::c_void {
6237     #[cfg(windows)]
6238     {
6239         #[link(name = "windows")]
6240         extern "system" {
6241             fn NdrRpcSsDefaultAllocate(size: usize) -> *mut ::std::ffi::c_void;
6242         }
6243         ::std::mem::transmute(NdrRpcSsDefaultAllocate(::std::mem::transmute(size)))
6244     }
6245     #[cfg(not(windows))]
6246     unimplemented!("Unsupported target OS");
6247 }
6248 #[inline]
NdrRpcSsDefaultFree(nodetofree: *const ::std::ffi::c_void)6249 pub unsafe fn NdrRpcSsDefaultFree(nodetofree: *const ::std::ffi::c_void) {
6250     #[cfg(windows)]
6251     {
6252         #[link(name = "windows")]
6253         extern "system" {
6254             fn NdrRpcSsDefaultFree(nodetofree: *const ::std::ffi::c_void);
6255         }
6256         ::std::mem::transmute(NdrRpcSsDefaultFree(::std::mem::transmute(nodetofree)))
6257     }
6258     #[cfg(not(windows))]
6259     unimplemented!("Unsupported target OS");
6260 }
6261 #[cfg(feature = "Win32_System_Com")]
6262 #[inline]
NdrRpcSsDisableAllocate(pmessage: *mut MIDL_STUB_MESSAGE)6263 pub unsafe fn NdrRpcSsDisableAllocate(pmessage: *mut MIDL_STUB_MESSAGE) {
6264     #[cfg(windows)]
6265     {
6266         #[link(name = "windows")]
6267         extern "system" {
6268             fn NdrRpcSsDisableAllocate(pmessage: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
6269         }
6270         ::std::mem::transmute(NdrRpcSsDisableAllocate(::std::mem::transmute(pmessage)))
6271     }
6272     #[cfg(not(windows))]
6273     unimplemented!("Unsupported target OS");
6274 }
6275 #[cfg(feature = "Win32_System_Com")]
6276 #[inline]
NdrRpcSsEnableAllocate(pmessage: *mut MIDL_STUB_MESSAGE)6277 pub unsafe fn NdrRpcSsEnableAllocate(pmessage: *mut MIDL_STUB_MESSAGE) {
6278     #[cfg(windows)]
6279     {
6280         #[link(name = "windows")]
6281         extern "system" {
6282             fn NdrRpcSsEnableAllocate(pmessage: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
6283         }
6284         ::std::mem::transmute(NdrRpcSsEnableAllocate(::std::mem::transmute(pmessage)))
6285     }
6286     #[cfg(not(windows))]
6287     unimplemented!("Unsupported target OS");
6288 }
6289 #[cfg(feature = "Win32_System_Com")]
6290 #[inline]
NdrSendReceive(pstubmsg: *mut MIDL_STUB_MESSAGE, pbufferend: *mut u8) -> *mut u86291 pub unsafe fn NdrSendReceive(pstubmsg: *mut MIDL_STUB_MESSAGE, pbufferend: *mut u8) -> *mut u8 {
6292     #[cfg(windows)]
6293     {
6294         #[link(name = "windows")]
6295         extern "system" {
6296             fn NdrSendReceive(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pbufferend: *mut u8) -> *mut u8;
6297         }
6298         ::std::mem::transmute(NdrSendReceive(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pbufferend)))
6299     }
6300     #[cfg(not(windows))]
6301     unimplemented!("Unsupported target OS");
6302 }
6303 #[inline]
NdrServerCall2(prpcmsg: *mut RPC_MESSAGE)6304 pub unsafe fn NdrServerCall2(prpcmsg: *mut RPC_MESSAGE) {
6305     #[cfg(windows)]
6306     {
6307         #[link(name = "windows")]
6308         extern "system" {
6309             fn NdrServerCall2(prpcmsg: *mut RPC_MESSAGE);
6310         }
6311         ::std::mem::transmute(NdrServerCall2(::std::mem::transmute(prpcmsg)))
6312     }
6313     #[cfg(not(windows))]
6314     unimplemented!("Unsupported target OS");
6315 }
6316 #[inline]
NdrServerCallAll(prpcmsg: *mut RPC_MESSAGE)6317 pub unsafe fn NdrServerCallAll(prpcmsg: *mut RPC_MESSAGE) {
6318     #[cfg(windows)]
6319     {
6320         #[link(name = "windows")]
6321         extern "system" {
6322             fn NdrServerCallAll(prpcmsg: *mut RPC_MESSAGE);
6323         }
6324         ::std::mem::transmute(NdrServerCallAll(::std::mem::transmute(prpcmsg)))
6325     }
6326     #[cfg(not(windows))]
6327     unimplemented!("Unsupported target OS");
6328 }
6329 #[inline]
NdrServerCallNdr64(prpcmsg: *mut RPC_MESSAGE)6330 pub unsafe fn NdrServerCallNdr64(prpcmsg: *mut RPC_MESSAGE) {
6331     #[cfg(windows)]
6332     {
6333         #[link(name = "windows")]
6334         extern "system" {
6335             fn NdrServerCallNdr64(prpcmsg: *mut RPC_MESSAGE);
6336         }
6337         ::std::mem::transmute(NdrServerCallNdr64(::std::mem::transmute(prpcmsg)))
6338     }
6339     #[cfg(not(windows))]
6340     unimplemented!("Unsupported target OS");
6341 }
6342 #[cfg(feature = "Win32_System_Com")]
6343 #[inline]
NdrServerContextMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::std::option::Option<NDR_RUNDOWN>)6344 pub unsafe fn NdrServerContextMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::std::option::Option<NDR_RUNDOWN>) {
6345     #[cfg(windows)]
6346     {
6347         #[link(name = "windows")]
6348         extern "system" {
6349             fn NdrServerContextMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::windows::runtime::RawPtr);
6350         }
6351         ::std::mem::transmute(NdrServerContextMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(contexthandle), ::std::mem::transmute(rundownroutine)))
6352     }
6353     #[cfg(not(windows))]
6354     unimplemented!("Unsupported target OS");
6355 }
6356 #[cfg(feature = "Win32_System_Com")]
6357 #[inline]
NdrServerContextNewMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::std::option::Option<NDR_RUNDOWN>, pformat: *mut u8)6358 pub unsafe fn NdrServerContextNewMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::std::option::Option<NDR_RUNDOWN>, pformat: *mut u8) {
6359     #[cfg(windows)]
6360     {
6361         #[link(name = "windows")]
6362         extern "system" {
6363             fn NdrServerContextNewMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, contexthandle: *mut NDR_SCONTEXT_1, rundownroutine: ::windows::runtime::RawPtr, pformat: *mut u8);
6364         }
6365         ::std::mem::transmute(NdrServerContextNewMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(contexthandle), ::std::mem::transmute(rundownroutine), ::std::mem::transmute(pformat)))
6366     }
6367     #[cfg(not(windows))]
6368     unimplemented!("Unsupported target OS");
6369 }
6370 #[cfg(feature = "Win32_System_Com")]
6371 #[inline]
NdrServerContextNewUnmarshall(pstubmsg: *const MIDL_STUB_MESSAGE, pformat: *const u8) -> *mut NDR_SCONTEXT_16372 pub unsafe fn NdrServerContextNewUnmarshall(pstubmsg: *const MIDL_STUB_MESSAGE, pformat: *const u8) -> *mut NDR_SCONTEXT_1 {
6373     #[cfg(windows)]
6374     {
6375         #[link(name = "windows")]
6376         extern "system" {
6377             fn NdrServerContextNewUnmarshall(pstubmsg: *const ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *const u8) -> *mut NDR_SCONTEXT_1;
6378         }
6379         ::std::mem::transmute(NdrServerContextNewUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6380     }
6381     #[cfg(not(windows))]
6382     unimplemented!("Unsupported target OS");
6383 }
6384 #[cfg(feature = "Win32_System_Com")]
6385 #[inline]
NdrServerContextUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE) -> *mut NDR_SCONTEXT_16386 pub unsafe fn NdrServerContextUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE) -> *mut NDR_SCONTEXT_1 {
6387     #[cfg(windows)]
6388     {
6389         #[link(name = "windows")]
6390         extern "system" {
6391             fn NdrServerContextUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>) -> *mut NDR_SCONTEXT_1;
6392         }
6393         ::std::mem::transmute(NdrServerContextUnmarshall(::std::mem::transmute(pstubmsg)))
6394     }
6395     #[cfg(not(windows))]
6396     unimplemented!("Unsupported target OS");
6397 }
6398 #[cfg(feature = "Win32_System_Com")]
6399 #[inline]
NdrServerInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u86400 pub unsafe fn NdrServerInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u8 {
6401     #[cfg(windows)]
6402     {
6403         #[link(name = "windows")]
6404         extern "system" {
6405             fn NdrServerInitialize(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u8;
6406         }
6407         ::std::mem::transmute(NdrServerInitialize(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor)))
6408     }
6409     #[cfg(not(windows))]
6410     unimplemented!("Unsupported target OS");
6411 }
6412 #[cfg(feature = "Win32_System_Com")]
6413 #[inline]
NdrServerInitializeMarshall(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE)6414 pub unsafe fn NdrServerInitializeMarshall(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE) {
6415     #[cfg(windows)]
6416     {
6417         #[link(name = "windows")]
6418         extern "system" {
6419             fn NdrServerInitializeMarshall(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
6420         }
6421         ::std::mem::transmute(NdrServerInitializeMarshall(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg)))
6422     }
6423     #[cfg(not(windows))]
6424     unimplemented!("Unsupported target OS");
6425 }
6426 #[cfg(feature = "Win32_System_Com")]
6427 #[inline]
NdrServerInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u86428 pub unsafe fn NdrServerInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u8 {
6429     #[cfg(windows)]
6430     {
6431         #[link(name = "windows")]
6432         extern "system" {
6433             fn NdrServerInitializeNew(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC) -> *mut u8;
6434         }
6435         ::std::mem::transmute(NdrServerInitializeNew(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor)))
6436     }
6437     #[cfg(not(windows))]
6438     unimplemented!("Unsupported target OS");
6439 }
6440 #[cfg(feature = "Win32_System_Com")]
6441 #[inline]
NdrServerInitializePartial(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, requestedbuffersize: u32)6442 pub unsafe fn NdrServerInitializePartial(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, requestedbuffersize: u32) {
6443     #[cfg(windows)]
6444     {
6445         #[link(name = "windows")]
6446         extern "system" {
6447             fn NdrServerInitializePartial(prpcmsg: *mut RPC_MESSAGE, pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC, requestedbuffersize: u32);
6448         }
6449         ::std::mem::transmute(NdrServerInitializePartial(::std::mem::transmute(prpcmsg), ::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(requestedbuffersize)))
6450     }
6451     #[cfg(not(windows))]
6452     unimplemented!("Unsupported target OS");
6453 }
6454 #[cfg(feature = "Win32_System_Com")]
6455 #[inline]
NdrServerInitializeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, prpcmsg: *mut RPC_MESSAGE) -> *mut u86456 pub unsafe fn NdrServerInitializeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pstubdescriptor: *mut MIDL_STUB_DESC, prpcmsg: *mut RPC_MESSAGE) -> *mut u8 {
6457     #[cfg(windows)]
6458     {
6459         #[link(name = "windows")]
6460         extern "system" {
6461             fn NdrServerInitializeUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pstubdescriptor: *mut MIDL_STUB_DESC, prpcmsg: *mut RPC_MESSAGE) -> *mut u8;
6462         }
6463         ::std::mem::transmute(NdrServerInitializeUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pstubdescriptor), ::std::mem::transmute(prpcmsg)))
6464     }
6465     #[cfg(not(windows))]
6466     unimplemented!("Unsupported target OS");
6467 }
6468 #[cfg(feature = "Win32_System_Com")]
6469 #[inline]
NdrSimpleStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6470 pub unsafe fn NdrSimpleStructBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6471     #[cfg(windows)]
6472     {
6473         #[link(name = "windows")]
6474         extern "system" {
6475             fn NdrSimpleStructBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6476         }
6477         ::std::mem::transmute(NdrSimpleStructBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6478     }
6479     #[cfg(not(windows))]
6480     unimplemented!("Unsupported target OS");
6481 }
6482 #[cfg(feature = "Win32_System_Com")]
6483 #[inline]
NdrSimpleStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6484 pub unsafe fn NdrSimpleStructFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6485     #[cfg(windows)]
6486     {
6487         #[link(name = "windows")]
6488         extern "system" {
6489             fn NdrSimpleStructFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6490         }
6491         ::std::mem::transmute(NdrSimpleStructFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6492     }
6493     #[cfg(not(windows))]
6494     unimplemented!("Unsupported target OS");
6495 }
6496 #[cfg(feature = "Win32_System_Com")]
6497 #[inline]
NdrSimpleStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u86498 pub unsafe fn NdrSimpleStructMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
6499     #[cfg(windows)]
6500     {
6501         #[link(name = "windows")]
6502         extern "system" {
6503             fn NdrSimpleStructMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
6504         }
6505         ::std::mem::transmute(NdrSimpleStructMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6506     }
6507     #[cfg(not(windows))]
6508     unimplemented!("Unsupported target OS");
6509 }
6510 #[cfg(feature = "Win32_System_Com")]
6511 #[inline]
NdrSimpleStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u326512 pub unsafe fn NdrSimpleStructMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
6513     #[cfg(windows)]
6514     {
6515         #[link(name = "windows")]
6516         extern "system" {
6517             fn NdrSimpleStructMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
6518         }
6519         ::std::mem::transmute(NdrSimpleStructMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6520     }
6521     #[cfg(not(windows))]
6522     unimplemented!("Unsupported target OS");
6523 }
6524 #[cfg(feature = "Win32_System_Com")]
6525 #[inline]
NdrSimpleStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86526 pub unsafe fn NdrSimpleStructUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6527     #[cfg(windows)]
6528     {
6529         #[link(name = "windows")]
6530         extern "system" {
6531             fn NdrSimpleStructUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6532         }
6533         ::std::mem::transmute(NdrSimpleStructUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6534     }
6535     #[cfg(not(windows))]
6536     unimplemented!("Unsupported target OS");
6537 }
6538 #[cfg(feature = "Win32_System_Com")]
6539 #[inline]
NdrSimpleTypeMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, formatchar: u8)6540 pub unsafe fn NdrSimpleTypeMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, formatchar: u8) {
6541     #[cfg(windows)]
6542     {
6543         #[link(name = "windows")]
6544         extern "system" {
6545             fn NdrSimpleTypeMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, formatchar: u8);
6546         }
6547         ::std::mem::transmute(NdrSimpleTypeMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(formatchar)))
6548     }
6549     #[cfg(not(windows))]
6550     unimplemented!("Unsupported target OS");
6551 }
6552 #[cfg(feature = "Win32_System_Com")]
6553 #[inline]
NdrSimpleTypeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, formatchar: u8)6554 pub unsafe fn NdrSimpleTypeUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, formatchar: u8) {
6555     #[cfg(windows)]
6556     {
6557         #[link(name = "windows")]
6558         extern "system" {
6559             fn NdrSimpleTypeUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, formatchar: u8);
6560         }
6561         ::std::mem::transmute(NdrSimpleTypeUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(formatchar)))
6562     }
6563     #[cfg(not(windows))]
6564     unimplemented!("Unsupported target OS");
6565 }
6566 #[inline]
NdrStubCall2(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i326567 pub unsafe fn NdrStubCall2(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32 {
6568     #[cfg(windows)]
6569     {
6570         #[link(name = "windows")]
6571         extern "system" {
6572             fn NdrStubCall2(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32;
6573         }
6574         ::std::mem::transmute(NdrStubCall2(::std::mem::transmute(pthis), ::std::mem::transmute(pchannel), ::std::mem::transmute(prpcmsg), ::std::mem::transmute(pdwstubphase)))
6575     }
6576     #[cfg(not(windows))]
6577     unimplemented!("Unsupported target OS");
6578 }
6579 #[inline]
NdrStubCall3(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i326580 pub unsafe fn NdrStubCall3(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32 {
6581     #[cfg(windows)]
6582     {
6583         #[link(name = "windows")]
6584         extern "system" {
6585             fn NdrStubCall3(pthis: *mut ::std::ffi::c_void, pchannel: *mut ::std::ffi::c_void, prpcmsg: *mut RPC_MESSAGE, pdwstubphase: *mut u32) -> i32;
6586         }
6587         ::std::mem::transmute(NdrStubCall3(::std::mem::transmute(pthis), ::std::mem::transmute(pchannel), ::std::mem::transmute(prpcmsg), ::std::mem::transmute(pdwstubphase)))
6588     }
6589     #[cfg(not(windows))]
6590     unimplemented!("Unsupported target OS");
6591 }
6592 #[cfg(feature = "Win32_System_Com")]
6593 #[inline]
NdrUserMarshalBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6594 pub unsafe fn NdrUserMarshalBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6595     #[cfg(windows)]
6596     {
6597         #[link(name = "windows")]
6598         extern "system" {
6599             fn NdrUserMarshalBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6600         }
6601         ::std::mem::transmute(NdrUserMarshalBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6602     }
6603     #[cfg(not(windows))]
6604     unimplemented!("Unsupported target OS");
6605 }
6606 #[cfg(feature = "Win32_System_Com")]
6607 #[inline]
NdrUserMarshalFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6608 pub unsafe fn NdrUserMarshalFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6609     #[cfg(windows)]
6610     {
6611         #[link(name = "windows")]
6612         extern "system" {
6613             fn NdrUserMarshalFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6614         }
6615         ::std::mem::transmute(NdrUserMarshalFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6616     }
6617     #[cfg(not(windows))]
6618     unimplemented!("Unsupported target OS");
6619 }
6620 #[cfg(feature = "Win32_System_Com")]
6621 #[inline]
NdrUserMarshalMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u86622 pub unsafe fn NdrUserMarshalMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
6623     #[cfg(windows)]
6624     {
6625         #[link(name = "windows")]
6626         extern "system" {
6627             fn NdrUserMarshalMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
6628         }
6629         ::std::mem::transmute(NdrUserMarshalMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6630     }
6631     #[cfg(not(windows))]
6632     unimplemented!("Unsupported target OS");
6633 }
6634 #[cfg(feature = "Win32_System_Com")]
6635 #[inline]
NdrUserMarshalMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u326636 pub unsafe fn NdrUserMarshalMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
6637     #[cfg(windows)]
6638     {
6639         #[link(name = "windows")]
6640         extern "system" {
6641             fn NdrUserMarshalMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
6642         }
6643         ::std::mem::transmute(NdrUserMarshalMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6644     }
6645     #[cfg(not(windows))]
6646     unimplemented!("Unsupported target OS");
6647 }
6648 #[inline]
NdrUserMarshalSimpleTypeConvert(pflags: *mut u32, pbuffer: *mut u8, formatchar: u8) -> *mut u86649 pub unsafe fn NdrUserMarshalSimpleTypeConvert(pflags: *mut u32, pbuffer: *mut u8, formatchar: u8) -> *mut u8 {
6650     #[cfg(windows)]
6651     {
6652         #[link(name = "windows")]
6653         extern "system" {
6654             fn NdrUserMarshalSimpleTypeConvert(pflags: *mut u32, pbuffer: *mut u8, formatchar: u8) -> *mut u8;
6655         }
6656         ::std::mem::transmute(NdrUserMarshalSimpleTypeConvert(::std::mem::transmute(pflags), ::std::mem::transmute(pbuffer), ::std::mem::transmute(formatchar)))
6657     }
6658     #[cfg(not(windows))]
6659     unimplemented!("Unsupported target OS");
6660 }
6661 #[cfg(feature = "Win32_System_Com")]
6662 #[inline]
NdrUserMarshalUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86663 pub unsafe fn NdrUserMarshalUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6664     #[cfg(windows)]
6665     {
6666         #[link(name = "windows")]
6667         extern "system" {
6668             fn NdrUserMarshalUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6669         }
6670         ::std::mem::transmute(NdrUserMarshalUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6671     }
6672     #[cfg(not(windows))]
6673     unimplemented!("Unsupported target OS");
6674 }
6675 #[cfg(feature = "Win32_System_Com")]
6676 #[inline]
NdrVaryingArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6677 pub unsafe fn NdrVaryingArrayBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6678     #[cfg(windows)]
6679     {
6680         #[link(name = "windows")]
6681         extern "system" {
6682             fn NdrVaryingArrayBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6683         }
6684         ::std::mem::transmute(NdrVaryingArrayBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6685     }
6686     #[cfg(not(windows))]
6687     unimplemented!("Unsupported target OS");
6688 }
6689 #[cfg(feature = "Win32_System_Com")]
6690 #[inline]
NdrVaryingArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6691 pub unsafe fn NdrVaryingArrayFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6692     #[cfg(windows)]
6693     {
6694         #[link(name = "windows")]
6695         extern "system" {
6696             fn NdrVaryingArrayFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6697         }
6698         ::std::mem::transmute(NdrVaryingArrayFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6699     }
6700     #[cfg(not(windows))]
6701     unimplemented!("Unsupported target OS");
6702 }
6703 #[cfg(feature = "Win32_System_Com")]
6704 #[inline]
NdrVaryingArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u86705 pub unsafe fn NdrVaryingArrayMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
6706     #[cfg(windows)]
6707     {
6708         #[link(name = "windows")]
6709         extern "system" {
6710             fn NdrVaryingArrayMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
6711         }
6712         ::std::mem::transmute(NdrVaryingArrayMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6713     }
6714     #[cfg(not(windows))]
6715     unimplemented!("Unsupported target OS");
6716 }
6717 #[cfg(feature = "Win32_System_Com")]
6718 #[inline]
NdrVaryingArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u326719 pub unsafe fn NdrVaryingArrayMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
6720     #[cfg(windows)]
6721     {
6722         #[link(name = "windows")]
6723         extern "system" {
6724             fn NdrVaryingArrayMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
6725         }
6726         ::std::mem::transmute(NdrVaryingArrayMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6727     }
6728     #[cfg(not(windows))]
6729     unimplemented!("Unsupported target OS");
6730 }
6731 #[cfg(feature = "Win32_System_Com")]
6732 #[inline]
NdrVaryingArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86733 pub unsafe fn NdrVaryingArrayUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6734     #[cfg(windows)]
6735     {
6736         #[link(name = "windows")]
6737         extern "system" {
6738             fn NdrVaryingArrayUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6739         }
6740         ::std::mem::transmute(NdrVaryingArrayUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6741     }
6742     #[cfg(not(windows))]
6743     unimplemented!("Unsupported target OS");
6744 }
6745 #[cfg(feature = "Win32_System_Com")]
6746 #[inline]
NdrXmitOrRepAsBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6747 pub unsafe fn NdrXmitOrRepAsBufferSize(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6748     #[cfg(windows)]
6749     {
6750         #[link(name = "windows")]
6751         extern "system" {
6752             fn NdrXmitOrRepAsBufferSize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6753         }
6754         ::std::mem::transmute(NdrXmitOrRepAsBufferSize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6755     }
6756     #[cfg(not(windows))]
6757     unimplemented!("Unsupported target OS");
6758 }
6759 #[cfg(feature = "Win32_System_Com")]
6760 #[inline]
NdrXmitOrRepAsFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8)6761 pub unsafe fn NdrXmitOrRepAsFree(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) {
6762     #[cfg(windows)]
6763     {
6764         #[link(name = "windows")]
6765         extern "system" {
6766             fn NdrXmitOrRepAsFree(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8);
6767         }
6768         ::std::mem::transmute(NdrXmitOrRepAsFree(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6769     }
6770     #[cfg(not(windows))]
6771     unimplemented!("Unsupported target OS");
6772 }
6773 #[cfg(feature = "Win32_System_Com")]
6774 #[inline]
NdrXmitOrRepAsMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u86775 pub unsafe fn NdrXmitOrRepAsMarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, pmemory: *mut u8, pformat: *mut u8) -> *mut u8 {
6776     #[cfg(windows)]
6777     {
6778         #[link(name = "windows")]
6779         extern "system" {
6780             fn NdrXmitOrRepAsMarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pmemory: *mut u8, pformat: *mut u8) -> *mut u8;
6781         }
6782         ::std::mem::transmute(NdrXmitOrRepAsMarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pmemory), ::std::mem::transmute(pformat)))
6783     }
6784     #[cfg(not(windows))]
6785     unimplemented!("Unsupported target OS");
6786 }
6787 #[cfg(feature = "Win32_System_Com")]
6788 #[inline]
NdrXmitOrRepAsMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u326789 pub unsafe fn NdrXmitOrRepAsMemorySize(pstubmsg: *mut MIDL_STUB_MESSAGE, pformat: *mut u8) -> u32 {
6790     #[cfg(windows)]
6791     {
6792         #[link(name = "windows")]
6793         extern "system" {
6794             fn NdrXmitOrRepAsMemorySize(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, pformat: *mut u8) -> u32;
6795         }
6796         ::std::mem::transmute(NdrXmitOrRepAsMemorySize(::std::mem::transmute(pstubmsg), ::std::mem::transmute(pformat)))
6797     }
6798     #[cfg(not(windows))]
6799     unimplemented!("Unsupported target OS");
6800 }
6801 #[cfg(feature = "Win32_System_Com")]
6802 #[inline]
NdrXmitOrRepAsUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u86803 pub unsafe fn NdrXmitOrRepAsUnmarshall(pstubmsg: *mut MIDL_STUB_MESSAGE, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8 {
6804     #[cfg(windows)]
6805     {
6806         #[link(name = "windows")]
6807         extern "system" {
6808             fn NdrXmitOrRepAsUnmarshall(pstubmsg: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>, ppmemory: *mut *mut u8, pformat: *mut u8, fmustalloc: u8) -> *mut u8;
6809         }
6810         ::std::mem::transmute(NdrXmitOrRepAsUnmarshall(::std::mem::transmute(pstubmsg), ::std::mem::transmute(ppmemory), ::std::mem::transmute(pformat), ::std::mem::transmute(fmustalloc)))
6811     }
6812     #[cfg(not(windows))]
6813     unimplemented!("Unsupported target OS");
6814 }
6815 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6816 pub type PFN_RPCNOTIFICATION_ROUTINE = unsafe extern "system" fn(pasync: *mut ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, context: *mut ::std::ffi::c_void, event: RPC_ASYNC_EVENT);
6817 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6818 #[repr(transparent)]
6819 pub struct PROXY_PHASE(pub i32);
6820 pub const PROXY_CALCSIZE: PROXY_PHASE = PROXY_PHASE(0i32);
6821 pub const PROXY_GETBUFFER: PROXY_PHASE = PROXY_PHASE(1i32);
6822 pub const PROXY_MARSHAL: PROXY_PHASE = PROXY_PHASE(2i32);
6823 pub const PROXY_SENDRECEIVE: PROXY_PHASE = PROXY_PHASE(3i32);
6824 pub const PROXY_UNMARSHAL: PROXY_PHASE = PROXY_PHASE(4i32);
6825 impl ::std::convert::From<i32> for PROXY_PHASE {
from(value: i32) -> Self6826     fn from(value: i32) -> Self {
6827         Self(value)
6828     }
6829 }
6830 unsafe impl ::windows::runtime::Abi for PROXY_PHASE {
6831     type Abi = Self;
6832     type DefaultType = Self;
6833 }
6834 pub type PRPC_RUNDOWN = unsafe extern "system" fn(associationcontext: *mut ::std::ffi::c_void);
6835 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6836 #[repr(C)]
6837 pub struct RDR_CALLOUT_STATE {
6838     pub LastError: RPC_STATUS,
6839     pub LastEEInfo: *mut ::std::ffi::c_void,
6840     pub LastCalledStage: RPC_HTTP_REDIRECTOR_STAGE,
6841     pub ServerName: *mut u16,
6842     pub ServerPort: *mut u16,
6843     pub RemoteUser: *mut u16,
6844     pub AuthType: *mut u16,
6845     pub ResourceTypePresent: u8,
6846     pub SessionIdPresent: u8,
6847     pub InterfacePresent: u8,
6848     pub ResourceType: ::windows::runtime::GUID,
6849     pub SessionId: ::windows::runtime::GUID,
6850     pub Interface: RPC_SYNTAX_IDENTIFIER,
6851     pub CertContext: *mut ::std::ffi::c_void,
6852 }
6853 impl RDR_CALLOUT_STATE {}
6854 impl ::std::default::Default for RDR_CALLOUT_STATE {
default() -> Self6855     fn default() -> Self {
6856         unsafe { ::std::mem::zeroed() }
6857     }
6858 }
6859 impl ::std::fmt::Debug for RDR_CALLOUT_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6860     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6861         fmt.debug_struct("RDR_CALLOUT_STATE")
6862             .field("LastError", &self.LastError)
6863             .field("LastEEInfo", &self.LastEEInfo)
6864             .field("LastCalledStage", &self.LastCalledStage)
6865             .field("ServerName", &self.ServerName)
6866             .field("ServerPort", &self.ServerPort)
6867             .field("RemoteUser", &self.RemoteUser)
6868             .field("AuthType", &self.AuthType)
6869             .field("ResourceTypePresent", &self.ResourceTypePresent)
6870             .field("SessionIdPresent", &self.SessionIdPresent)
6871             .field("InterfacePresent", &self.InterfacePresent)
6872             .field("ResourceType", &self.ResourceType)
6873             .field("SessionId", &self.SessionId)
6874             .field("Interface", &self.Interface)
6875             .field("CertContext", &self.CertContext)
6876             .finish()
6877     }
6878 }
6879 impl ::std::cmp::PartialEq for RDR_CALLOUT_STATE {
eq(&self, other: &Self) -> bool6880     fn eq(&self, other: &Self) -> bool {
6881         self.LastError == other.LastError
6882             && self.LastEEInfo == other.LastEEInfo
6883             && self.LastCalledStage == other.LastCalledStage
6884             && self.ServerName == other.ServerName
6885             && self.ServerPort == other.ServerPort
6886             && self.RemoteUser == other.RemoteUser
6887             && self.AuthType == other.AuthType
6888             && self.ResourceTypePresent == other.ResourceTypePresent
6889             && self.SessionIdPresent == other.SessionIdPresent
6890             && self.InterfacePresent == other.InterfacePresent
6891             && self.ResourceType == other.ResourceType
6892             && self.SessionId == other.SessionId
6893             && self.Interface == other.Interface
6894             && self.CertContext == other.CertContext
6895     }
6896 }
6897 impl ::std::cmp::Eq for RDR_CALLOUT_STATE {}
6898 unsafe impl ::windows::runtime::Abi for RDR_CALLOUT_STATE {
6899     type Abi = Self;
6900     type DefaultType = Self;
6901 }
6902 pub const RPCFLG_ACCESSIBILITY_BIT1: u32 = 1048576u32;
6903 pub const RPCFLG_ACCESSIBILITY_BIT2: u32 = 2097152u32;
6904 pub const RPCFLG_ACCESS_LOCAL: u32 = 4194304u32;
6905 pub const RPCFLG_ASYNCHRONOUS: u32 = 1073741824u32;
6906 pub const RPCFLG_AUTO_COMPLETE: u32 = 134217728u32;
6907 pub const RPCFLG_HAS_CALLBACK: u32 = 67108864u32;
6908 pub const RPCFLG_HAS_GUARANTEE: u32 = 16u32;
6909 pub const RPCFLG_HAS_MULTI_SYNTAXES: u32 = 33554432u32;
6910 pub const RPCFLG_INPUT_SYNCHRONOUS: u32 = 536870912u32;
6911 pub const RPCFLG_LOCAL_CALL: u32 = 268435456u32;
6912 pub const RPCFLG_MESSAGE: u32 = 16777216u32;
6913 pub const RPCFLG_NDR64_CONTAINS_ARM_LAYOUT: u32 = 67108864u32;
6914 pub const RPCFLG_NON_NDR: u32 = 2147483648u32;
6915 pub const RPCFLG_SENDER_WAITING_FOR_REPLY: u32 = 8388608u32;
6916 pub const RPCFLG_WINRT_REMOTE_ASYNC: u32 = 32u32;
6917 pub type RPCLT_PDU_FILTER_FUNC = unsafe extern "system" fn(buffer: *mut ::std::ffi::c_void, bufferlength: u32, fdatagram: i32);
6918 pub type RPC_ADDRESS_CHANGE_FN = unsafe extern "system" fn(arg: *mut ::std::ffi::c_void);
6919 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6920 #[repr(transparent)]
6921 pub struct RPC_ADDRESS_CHANGE_TYPE(pub i32);
6922 pub const PROTOCOL_NOT_LOADED: RPC_ADDRESS_CHANGE_TYPE = RPC_ADDRESS_CHANGE_TYPE(1i32);
6923 pub const PROTOCOL_LOADED: RPC_ADDRESS_CHANGE_TYPE = RPC_ADDRESS_CHANGE_TYPE(2i32);
6924 pub const PROTOCOL_ADDRESS_CHANGE: RPC_ADDRESS_CHANGE_TYPE = RPC_ADDRESS_CHANGE_TYPE(3i32);
6925 impl ::std::convert::From<i32> for RPC_ADDRESS_CHANGE_TYPE {
from(value: i32) -> Self6926     fn from(value: i32) -> Self {
6927         Self(value)
6928     }
6929 }
6930 unsafe impl ::windows::runtime::Abi for RPC_ADDRESS_CHANGE_TYPE {
6931     type Abi = Self;
6932     type DefaultType = Self;
6933 }
6934 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6935 #[repr(transparent)]
6936 pub struct RPC_ASYNC_EVENT(pub i32);
6937 pub const RpcCallComplete: RPC_ASYNC_EVENT = RPC_ASYNC_EVENT(0i32);
6938 pub const RpcSendComplete: RPC_ASYNC_EVENT = RPC_ASYNC_EVENT(1i32);
6939 pub const RpcReceiveComplete: RPC_ASYNC_EVENT = RPC_ASYNC_EVENT(2i32);
6940 pub const RpcClientDisconnect: RPC_ASYNC_EVENT = RPC_ASYNC_EVENT(3i32);
6941 pub const RpcClientCancel: RPC_ASYNC_EVENT = RPC_ASYNC_EVENT(4i32);
6942 impl ::std::convert::From<i32> for RPC_ASYNC_EVENT {
from(value: i32) -> Self6943     fn from(value: i32) -> Self {
6944         Self(value)
6945     }
6946 }
6947 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_EVENT {
6948     type Abi = Self;
6949     type DefaultType = Self;
6950 }
6951 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6952 impl ::std::clone::Clone for RPC_ASYNC_NOTIFICATION_INFO {
clone(&self) -> Self6953     fn clone(&self) -> Self {
6954         unimplemented!()
6955     }
6956 }
6957 #[repr(C)]
6958 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6959 pub union RPC_ASYNC_NOTIFICATION_INFO {
6960     pub APC: ::std::mem::ManuallyDrop<RPC_ASYNC_NOTIFICATION_INFO_0>,
6961     pub IOC: RPC_ASYNC_NOTIFICATION_INFO_1,
6962     pub IntPtr: RPC_ASYNC_NOTIFICATION_INFO_2,
6963     pub hEvent: super::super::Foundation::HANDLE,
6964     pub NotificationRoutine: ::windows::runtime::RawPtr,
6965 }
6966 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6967 impl RPC_ASYNC_NOTIFICATION_INFO {}
6968 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6969 impl ::std::default::Default for RPC_ASYNC_NOTIFICATION_INFO {
default() -> Self6970     fn default() -> Self {
6971         unsafe { ::std::mem::zeroed() }
6972     }
6973 }
6974 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6975 impl ::std::cmp::PartialEq for RPC_ASYNC_NOTIFICATION_INFO {
eq(&self, _other: &Self) -> bool6976     fn eq(&self, _other: &Self) -> bool {
6977         unimplemented!()
6978     }
6979 }
6980 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6981 impl ::std::cmp::Eq for RPC_ASYNC_NOTIFICATION_INFO {}
6982 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6983 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_NOTIFICATION_INFO {
6984     type Abi = ::std::mem::ManuallyDrop<Self>;
6985     type DefaultType = Self;
6986 }
6987 #[derive(:: std :: clone :: Clone)]
6988 #[repr(C)]
6989 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6990 pub struct RPC_ASYNC_NOTIFICATION_INFO_0 {
6991     pub NotificationRoutine: ::std::option::Option<PFN_RPCNOTIFICATION_ROUTINE>,
6992     pub hThread: super::super::Foundation::HANDLE,
6993 }
6994 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6995 impl RPC_ASYNC_NOTIFICATION_INFO_0 {}
6996 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
6997 impl ::std::default::Default for RPC_ASYNC_NOTIFICATION_INFO_0 {
default() -> Self6998     fn default() -> Self {
6999         unsafe { ::std::mem::zeroed() }
7000     }
7001 }
7002 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7003 impl ::std::fmt::Debug for RPC_ASYNC_NOTIFICATION_INFO_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7004     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7005         fmt.debug_struct("_APC_e__Struct").field("hThread", &self.hThread).finish()
7006     }
7007 }
7008 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7009 impl ::std::cmp::PartialEq for RPC_ASYNC_NOTIFICATION_INFO_0 {
eq(&self, other: &Self) -> bool7010     fn eq(&self, other: &Self) -> bool {
7011         self.NotificationRoutine.map(|f| f as usize) == other.NotificationRoutine.map(|f| f as usize) && self.hThread == other.hThread
7012     }
7013 }
7014 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7015 impl ::std::cmp::Eq for RPC_ASYNC_NOTIFICATION_INFO_0 {}
7016 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7017 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_NOTIFICATION_INFO_0 {
7018     type Abi = ::std::mem::ManuallyDrop<Self>;
7019     type DefaultType = Self;
7020 }
7021 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7022 #[repr(C)]
7023 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7024 pub struct RPC_ASYNC_NOTIFICATION_INFO_1 {
7025     pub hIOPort: super::super::Foundation::HANDLE,
7026     pub dwNumberOfBytesTransferred: u32,
7027     pub dwCompletionKey: usize,
7028     pub lpOverlapped: *mut super::IO::OVERLAPPED,
7029 }
7030 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7031 impl RPC_ASYNC_NOTIFICATION_INFO_1 {}
7032 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7033 impl ::std::default::Default for RPC_ASYNC_NOTIFICATION_INFO_1 {
default() -> Self7034     fn default() -> Self {
7035         unsafe { ::std::mem::zeroed() }
7036     }
7037 }
7038 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7039 impl ::std::fmt::Debug for RPC_ASYNC_NOTIFICATION_INFO_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7040     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7041         fmt.debug_struct("_IOC_e__Struct").field("hIOPort", &self.hIOPort).field("dwNumberOfBytesTransferred", &self.dwNumberOfBytesTransferred).field("dwCompletionKey", &self.dwCompletionKey).field("lpOverlapped", &self.lpOverlapped).finish()
7042     }
7043 }
7044 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7045 impl ::std::cmp::PartialEq for RPC_ASYNC_NOTIFICATION_INFO_1 {
eq(&self, other: &Self) -> bool7046     fn eq(&self, other: &Self) -> bool {
7047         self.hIOPort == other.hIOPort && self.dwNumberOfBytesTransferred == other.dwNumberOfBytesTransferred && self.dwCompletionKey == other.dwCompletionKey && self.lpOverlapped == other.lpOverlapped
7048     }
7049 }
7050 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7051 impl ::std::cmp::Eq for RPC_ASYNC_NOTIFICATION_INFO_1 {}
7052 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7053 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_NOTIFICATION_INFO_1 {
7054     type Abi = Self;
7055     type DefaultType = Self;
7056 }
7057 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7058 #[repr(C)]
7059 #[cfg(feature = "Win32_Foundation")]
7060 pub struct RPC_ASYNC_NOTIFICATION_INFO_2 {
7061     pub hWnd: super::super::Foundation::HWND,
7062     pub Msg: u32,
7063 }
7064 #[cfg(feature = "Win32_Foundation")]
7065 impl RPC_ASYNC_NOTIFICATION_INFO_2 {}
7066 #[cfg(feature = "Win32_Foundation")]
7067 impl ::std::default::Default for RPC_ASYNC_NOTIFICATION_INFO_2 {
default() -> Self7068     fn default() -> Self {
7069         unsafe { ::std::mem::zeroed() }
7070     }
7071 }
7072 #[cfg(feature = "Win32_Foundation")]
7073 impl ::std::fmt::Debug for RPC_ASYNC_NOTIFICATION_INFO_2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7074     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7075         fmt.debug_struct("_IntPtr_e__Struct").field("hWnd", &self.hWnd).field("Msg", &self.Msg).finish()
7076     }
7077 }
7078 #[cfg(feature = "Win32_Foundation")]
7079 impl ::std::cmp::PartialEq for RPC_ASYNC_NOTIFICATION_INFO_2 {
eq(&self, other: &Self) -> bool7080     fn eq(&self, other: &Self) -> bool {
7081         self.hWnd == other.hWnd && self.Msg == other.Msg
7082     }
7083 }
7084 #[cfg(feature = "Win32_Foundation")]
7085 impl ::std::cmp::Eq for RPC_ASYNC_NOTIFICATION_INFO_2 {}
7086 #[cfg(feature = "Win32_Foundation")]
7087 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_NOTIFICATION_INFO_2 {
7088     type Abi = Self;
7089     type DefaultType = Self;
7090 }
7091 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7092 impl ::std::clone::Clone for RPC_ASYNC_STATE {
clone(&self) -> Self7093     fn clone(&self) -> Self {
7094         unimplemented!()
7095     }
7096 }
7097 #[repr(C)]
7098 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7099 pub struct RPC_ASYNC_STATE {
7100     pub Size: u32,
7101     pub Signature: u32,
7102     pub Lock: i32,
7103     pub Flags: u32,
7104     pub StubInfo: *mut ::std::ffi::c_void,
7105     pub UserInfo: *mut ::std::ffi::c_void,
7106     pub RuntimeInfo: *mut ::std::ffi::c_void,
7107     pub Event: RPC_ASYNC_EVENT,
7108     pub NotificationType: RPC_NOTIFICATION_TYPES,
7109     pub u: RPC_ASYNC_NOTIFICATION_INFO,
7110     pub Reserved: [isize; 4],
7111 }
7112 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7113 impl RPC_ASYNC_STATE {}
7114 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7115 impl ::std::default::Default for RPC_ASYNC_STATE {
default() -> Self7116     fn default() -> Self {
7117         unsafe { ::std::mem::zeroed() }
7118     }
7119 }
7120 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7121 impl ::std::cmp::PartialEq for RPC_ASYNC_STATE {
eq(&self, _other: &Self) -> bool7122     fn eq(&self, _other: &Self) -> bool {
7123         unimplemented!()
7124     }
7125 }
7126 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7127 impl ::std::cmp::Eq for RPC_ASYNC_STATE {}
7128 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7129 unsafe impl ::windows::runtime::Abi for RPC_ASYNC_STATE {
7130     type Abi = ::std::mem::ManuallyDrop<Self>;
7131     type DefaultType = Self;
7132 }
7133 pub type RPC_AUTH_KEY_RETRIEVAL_FN = unsafe extern "system" fn(arg: *const ::std::ffi::c_void, serverprincname: *const u16, keyver: u32, key: *mut *mut ::std::ffi::c_void, status: *mut RPC_STATUS);
7134 pub const RPC_BHO_EXCLUSIVE_AND_GUARANTEED: u32 = 4u32;
7135 pub const RPC_BHT_OBJECT_UUID_VALID: u32 = 1u32;
7136 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7137 #[repr(transparent)]
7138 pub struct RPC_BINDING_HANDLE_OPTIONS_FLAGS(pub u32);
7139 pub const RPC_BHO_NONCAUSAL: RPC_BINDING_HANDLE_OPTIONS_FLAGS = RPC_BINDING_HANDLE_OPTIONS_FLAGS(1u32);
7140 pub const RPC_BHO_DONTLINGER: RPC_BINDING_HANDLE_OPTIONS_FLAGS = RPC_BINDING_HANDLE_OPTIONS_FLAGS(2u32);
7141 impl ::std::convert::From<u32> for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
from(value: u32) -> Self7142     fn from(value: u32) -> Self {
7143         Self(value)
7144     }
7145 }
7146 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
7147     type Abi = Self;
7148     type DefaultType = Self;
7149 }
7150 impl ::std::ops::BitOr for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
7151     type Output = Self;
bitor(self, rhs: Self) -> Self7152     fn bitor(self, rhs: Self) -> Self {
7153         Self(self.0 | rhs.0)
7154     }
7155 }
7156 impl ::std::ops::BitAnd for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
7157     type Output = Self;
bitand(self, rhs: Self) -> Self7158     fn bitand(self, rhs: Self) -> Self {
7159         Self(self.0 & rhs.0)
7160     }
7161 }
7162 impl ::std::ops::BitOrAssign for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
bitor_assign(&mut self, rhs: Self)7163     fn bitor_assign(&mut self, rhs: Self) {
7164         self.0.bitor_assign(rhs.0)
7165     }
7166 }
7167 impl ::std::ops::BitAndAssign for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
bitand_assign(&mut self, rhs: Self)7168     fn bitand_assign(&mut self, rhs: Self) {
7169         self.0.bitand_assign(rhs.0)
7170     }
7171 }
7172 impl ::std::ops::Not for RPC_BINDING_HANDLE_OPTIONS_FLAGS {
7173     type Output = Self;
not(self) -> Self7174     fn not(self) -> Self {
7175         Self(self.0.not())
7176     }
7177 }
7178 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7179 #[repr(C)]
7180 pub struct RPC_BINDING_HANDLE_OPTIONS_V1 {
7181     pub Version: u32,
7182     pub Flags: RPC_BINDING_HANDLE_OPTIONS_FLAGS,
7183     pub ComTimeout: u32,
7184     pub CallTimeout: u32,
7185 }
7186 impl RPC_BINDING_HANDLE_OPTIONS_V1 {}
7187 impl ::std::default::Default for RPC_BINDING_HANDLE_OPTIONS_V1 {
default() -> Self7188     fn default() -> Self {
7189         unsafe { ::std::mem::zeroed() }
7190     }
7191 }
7192 impl ::std::fmt::Debug for RPC_BINDING_HANDLE_OPTIONS_V1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7193     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7194         fmt.debug_struct("RPC_BINDING_HANDLE_OPTIONS_V1").field("Version", &self.Version).field("Flags", &self.Flags).field("ComTimeout", &self.ComTimeout).field("CallTimeout", &self.CallTimeout).finish()
7195     }
7196 }
7197 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_OPTIONS_V1 {
eq(&self, other: &Self) -> bool7198     fn eq(&self, other: &Self) -> bool {
7199         self.Version == other.Version && self.Flags == other.Flags && self.ComTimeout == other.ComTimeout && self.CallTimeout == other.CallTimeout
7200     }
7201 }
7202 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_OPTIONS_V1 {}
7203 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_OPTIONS_V1 {
7204     type Abi = Self;
7205     type DefaultType = Self;
7206 }
7207 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7208 #[repr(C)]
7209 #[cfg(feature = "Win32_System_Com")]
7210 pub struct RPC_BINDING_HANDLE_SECURITY_V1_A {
7211     pub Version: u32,
7212     pub ServerPrincName: *mut u8,
7213     pub AuthnLevel: u32,
7214     pub AuthnSvc: u32,
7215     pub AuthIdentity: *mut SEC_WINNT_AUTH_IDENTITY_A,
7216     pub SecurityQos: *mut RPC_SECURITY_QOS,
7217 }
7218 #[cfg(feature = "Win32_System_Com")]
7219 impl RPC_BINDING_HANDLE_SECURITY_V1_A {}
7220 #[cfg(feature = "Win32_System_Com")]
7221 impl ::std::default::Default for RPC_BINDING_HANDLE_SECURITY_V1_A {
default() -> Self7222     fn default() -> Self {
7223         unsafe { ::std::mem::zeroed() }
7224     }
7225 }
7226 #[cfg(feature = "Win32_System_Com")]
7227 impl ::std::fmt::Debug for RPC_BINDING_HANDLE_SECURITY_V1_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7228     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7229         fmt.debug_struct("RPC_BINDING_HANDLE_SECURITY_V1_A").field("Version", &self.Version).field("ServerPrincName", &self.ServerPrincName).field("AuthnLevel", &self.AuthnLevel).field("AuthnSvc", &self.AuthnSvc).field("AuthIdentity", &self.AuthIdentity).field("SecurityQos", &self.SecurityQos).finish()
7230     }
7231 }
7232 #[cfg(feature = "Win32_System_Com")]
7233 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_SECURITY_V1_A {
eq(&self, other: &Self) -> bool7234     fn eq(&self, other: &Self) -> bool {
7235         self.Version == other.Version && self.ServerPrincName == other.ServerPrincName && self.AuthnLevel == other.AuthnLevel && self.AuthnSvc == other.AuthnSvc && self.AuthIdentity == other.AuthIdentity && self.SecurityQos == other.SecurityQos
7236     }
7237 }
7238 #[cfg(feature = "Win32_System_Com")]
7239 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_SECURITY_V1_A {}
7240 #[cfg(feature = "Win32_System_Com")]
7241 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_SECURITY_V1_A {
7242     type Abi = Self;
7243     type DefaultType = Self;
7244 }
7245 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7246 #[repr(C)]
7247 #[cfg(feature = "Win32_System_Com")]
7248 pub struct RPC_BINDING_HANDLE_SECURITY_V1_W {
7249     pub Version: u32,
7250     pub ServerPrincName: *mut u16,
7251     pub AuthnLevel: u32,
7252     pub AuthnSvc: u32,
7253     pub AuthIdentity: *mut SEC_WINNT_AUTH_IDENTITY_W,
7254     pub SecurityQos: *mut RPC_SECURITY_QOS,
7255 }
7256 #[cfg(feature = "Win32_System_Com")]
7257 impl RPC_BINDING_HANDLE_SECURITY_V1_W {}
7258 #[cfg(feature = "Win32_System_Com")]
7259 impl ::std::default::Default for RPC_BINDING_HANDLE_SECURITY_V1_W {
default() -> Self7260     fn default() -> Self {
7261         unsafe { ::std::mem::zeroed() }
7262     }
7263 }
7264 #[cfg(feature = "Win32_System_Com")]
7265 impl ::std::fmt::Debug for RPC_BINDING_HANDLE_SECURITY_V1_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7266     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7267         fmt.debug_struct("RPC_BINDING_HANDLE_SECURITY_V1_W").field("Version", &self.Version).field("ServerPrincName", &self.ServerPrincName).field("AuthnLevel", &self.AuthnLevel).field("AuthnSvc", &self.AuthnSvc).field("AuthIdentity", &self.AuthIdentity).field("SecurityQos", &self.SecurityQos).finish()
7268     }
7269 }
7270 #[cfg(feature = "Win32_System_Com")]
7271 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_SECURITY_V1_W {
eq(&self, other: &Self) -> bool7272     fn eq(&self, other: &Self) -> bool {
7273         self.Version == other.Version && self.ServerPrincName == other.ServerPrincName && self.AuthnLevel == other.AuthnLevel && self.AuthnSvc == other.AuthnSvc && self.AuthIdentity == other.AuthIdentity && self.SecurityQos == other.SecurityQos
7274     }
7275 }
7276 #[cfg(feature = "Win32_System_Com")]
7277 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_SECURITY_V1_W {}
7278 #[cfg(feature = "Win32_System_Com")]
7279 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_SECURITY_V1_W {
7280     type Abi = Self;
7281     type DefaultType = Self;
7282 }
7283 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7284 #[repr(C)]
7285 pub struct RPC_BINDING_HANDLE_TEMPLATE_V1_A {
7286     pub Version: u32,
7287     pub Flags: u32,
7288     pub ProtocolSequence: u32,
7289     pub NetworkAddress: *mut u8,
7290     pub StringEndpoint: *mut u8,
7291     pub u1: RPC_BINDING_HANDLE_TEMPLATE_V1_A_0,
7292     pub ObjectUuid: ::windows::runtime::GUID,
7293 }
7294 impl RPC_BINDING_HANDLE_TEMPLATE_V1_A {}
7295 impl ::std::default::Default for RPC_BINDING_HANDLE_TEMPLATE_V1_A {
default() -> Self7296     fn default() -> Self {
7297         unsafe { ::std::mem::zeroed() }
7298     }
7299 }
7300 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_TEMPLATE_V1_A {
eq(&self, _other: &Self) -> bool7301     fn eq(&self, _other: &Self) -> bool {
7302         unimplemented!()
7303     }
7304 }
7305 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_TEMPLATE_V1_A {}
7306 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_TEMPLATE_V1_A {
7307     type Abi = Self;
7308     type DefaultType = Self;
7309 }
7310 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7311 #[repr(C)]
7312 pub union RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {
7313     pub Reserved: *mut u8,
7314 }
7315 impl RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {}
7316 impl ::std::default::Default for RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {
default() -> Self7317     fn default() -> Self {
7318         unsafe { ::std::mem::zeroed() }
7319     }
7320 }
7321 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {
eq(&self, _other: &Self) -> bool7322     fn eq(&self, _other: &Self) -> bool {
7323         unimplemented!()
7324     }
7325 }
7326 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {}
7327 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_TEMPLATE_V1_A_0 {
7328     type Abi = Self;
7329     type DefaultType = Self;
7330 }
7331 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7332 #[repr(C)]
7333 pub struct RPC_BINDING_HANDLE_TEMPLATE_V1_W {
7334     pub Version: u32,
7335     pub Flags: u32,
7336     pub ProtocolSequence: u32,
7337     pub NetworkAddress: *mut u16,
7338     pub StringEndpoint: *mut u16,
7339     pub u1: RPC_BINDING_HANDLE_TEMPLATE_V1_W_0,
7340     pub ObjectUuid: ::windows::runtime::GUID,
7341 }
7342 impl RPC_BINDING_HANDLE_TEMPLATE_V1_W {}
7343 impl ::std::default::Default for RPC_BINDING_HANDLE_TEMPLATE_V1_W {
default() -> Self7344     fn default() -> Self {
7345         unsafe { ::std::mem::zeroed() }
7346     }
7347 }
7348 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_TEMPLATE_V1_W {
eq(&self, _other: &Self) -> bool7349     fn eq(&self, _other: &Self) -> bool {
7350         unimplemented!()
7351     }
7352 }
7353 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_TEMPLATE_V1_W {}
7354 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_TEMPLATE_V1_W {
7355     type Abi = Self;
7356     type DefaultType = Self;
7357 }
7358 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7359 #[repr(C)]
7360 pub union RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {
7361     pub Reserved: *mut u16,
7362 }
7363 impl RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {}
7364 impl ::std::default::Default for RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {
default() -> Self7365     fn default() -> Self {
7366         unsafe { ::std::mem::zeroed() }
7367     }
7368 }
7369 impl ::std::cmp::PartialEq for RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {
eq(&self, _other: &Self) -> bool7370     fn eq(&self, _other: &Self) -> bool {
7371         unimplemented!()
7372     }
7373 }
7374 impl ::std::cmp::Eq for RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {}
7375 unsafe impl ::windows::runtime::Abi for RPC_BINDING_HANDLE_TEMPLATE_V1_W_0 {
7376     type Abi = Self;
7377     type DefaultType = Self;
7378 }
7379 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7380 #[repr(C)]
7381 pub struct RPC_BINDING_VECTOR {
7382     pub Count: u32,
7383     pub BindingH: [*mut ::std::ffi::c_void; 1],
7384 }
7385 impl RPC_BINDING_VECTOR {}
7386 impl ::std::default::Default for RPC_BINDING_VECTOR {
default() -> Self7387     fn default() -> Self {
7388         unsafe { ::std::mem::zeroed() }
7389     }
7390 }
7391 impl ::std::fmt::Debug for RPC_BINDING_VECTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7392     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7393         fmt.debug_struct("RPC_BINDING_VECTOR").field("Count", &self.Count).field("BindingH", &self.BindingH).finish()
7394     }
7395 }
7396 impl ::std::cmp::PartialEq for RPC_BINDING_VECTOR {
eq(&self, other: &Self) -> bool7397     fn eq(&self, other: &Self) -> bool {
7398         self.Count == other.Count && self.BindingH == other.BindingH
7399     }
7400 }
7401 impl ::std::cmp::Eq for RPC_BINDING_VECTOR {}
7402 unsafe impl ::windows::runtime::Abi for RPC_BINDING_VECTOR {
7403     type Abi = Self;
7404     type DefaultType = Self;
7405 }
7406 pub type RPC_BLOCKING_FN = unsafe extern "system" fn(hwnd: *mut ::std::ffi::c_void, context: *mut ::std::ffi::c_void, hsyncevent: *mut ::std::ffi::c_void) -> RPC_STATUS;
7407 pub const RPC_BUFFER_ASYNC: u32 = 32768u32;
7408 pub const RPC_BUFFER_COMPLETE: u32 = 4096u32;
7409 pub const RPC_BUFFER_EXTRA: u32 = 16384u32;
7410 pub const RPC_BUFFER_NONOTIFY: u32 = 65536u32;
7411 pub const RPC_BUFFER_PARTIAL: u32 = 8192u32;
7412 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7413 #[repr(C)]
7414 #[cfg(feature = "Win32_Foundation")]
7415 pub struct RPC_CALL_ATTRIBUTES_V1_A {
7416     pub Version: u32,
7417     pub Flags: u32,
7418     pub ServerPrincipalNameBufferLength: u32,
7419     pub ServerPrincipalName: *mut u8,
7420     pub ClientPrincipalNameBufferLength: u32,
7421     pub ClientPrincipalName: *mut u8,
7422     pub AuthenticationLevel: u32,
7423     pub AuthenticationService: u32,
7424     pub NullSession: super::super::Foundation::BOOL,
7425 }
7426 #[cfg(feature = "Win32_Foundation")]
7427 impl RPC_CALL_ATTRIBUTES_V1_A {}
7428 #[cfg(feature = "Win32_Foundation")]
7429 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V1_A {
default() -> Self7430     fn default() -> Self {
7431         unsafe { ::std::mem::zeroed() }
7432     }
7433 }
7434 #[cfg(feature = "Win32_Foundation")]
7435 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V1_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7436     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7437         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V1_A")
7438             .field("Version", &self.Version)
7439             .field("Flags", &self.Flags)
7440             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7441             .field("ServerPrincipalName", &self.ServerPrincipalName)
7442             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7443             .field("ClientPrincipalName", &self.ClientPrincipalName)
7444             .field("AuthenticationLevel", &self.AuthenticationLevel)
7445             .field("AuthenticationService", &self.AuthenticationService)
7446             .field("NullSession", &self.NullSession)
7447             .finish()
7448     }
7449 }
7450 #[cfg(feature = "Win32_Foundation")]
7451 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V1_A {
eq(&self, other: &Self) -> bool7452     fn eq(&self, other: &Self) -> bool {
7453         self.Version == other.Version
7454             && self.Flags == other.Flags
7455             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7456             && self.ServerPrincipalName == other.ServerPrincipalName
7457             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7458             && self.ClientPrincipalName == other.ClientPrincipalName
7459             && self.AuthenticationLevel == other.AuthenticationLevel
7460             && self.AuthenticationService == other.AuthenticationService
7461             && self.NullSession == other.NullSession
7462     }
7463 }
7464 #[cfg(feature = "Win32_Foundation")]
7465 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V1_A {}
7466 #[cfg(feature = "Win32_Foundation")]
7467 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V1_A {
7468     type Abi = Self;
7469     type DefaultType = Self;
7470 }
7471 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7472 #[repr(C)]
7473 #[cfg(feature = "Win32_Foundation")]
7474 pub struct RPC_CALL_ATTRIBUTES_V1_W {
7475     pub Version: u32,
7476     pub Flags: u32,
7477     pub ServerPrincipalNameBufferLength: u32,
7478     pub ServerPrincipalName: *mut u16,
7479     pub ClientPrincipalNameBufferLength: u32,
7480     pub ClientPrincipalName: *mut u16,
7481     pub AuthenticationLevel: u32,
7482     pub AuthenticationService: u32,
7483     pub NullSession: super::super::Foundation::BOOL,
7484 }
7485 #[cfg(feature = "Win32_Foundation")]
7486 impl RPC_CALL_ATTRIBUTES_V1_W {}
7487 #[cfg(feature = "Win32_Foundation")]
7488 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V1_W {
default() -> Self7489     fn default() -> Self {
7490         unsafe { ::std::mem::zeroed() }
7491     }
7492 }
7493 #[cfg(feature = "Win32_Foundation")]
7494 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V1_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7495     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7496         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V1_W")
7497             .field("Version", &self.Version)
7498             .field("Flags", &self.Flags)
7499             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7500             .field("ServerPrincipalName", &self.ServerPrincipalName)
7501             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7502             .field("ClientPrincipalName", &self.ClientPrincipalName)
7503             .field("AuthenticationLevel", &self.AuthenticationLevel)
7504             .field("AuthenticationService", &self.AuthenticationService)
7505             .field("NullSession", &self.NullSession)
7506             .finish()
7507     }
7508 }
7509 #[cfg(feature = "Win32_Foundation")]
7510 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V1_W {
eq(&self, other: &Self) -> bool7511     fn eq(&self, other: &Self) -> bool {
7512         self.Version == other.Version
7513             && self.Flags == other.Flags
7514             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7515             && self.ServerPrincipalName == other.ServerPrincipalName
7516             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7517             && self.ClientPrincipalName == other.ClientPrincipalName
7518             && self.AuthenticationLevel == other.AuthenticationLevel
7519             && self.AuthenticationService == other.AuthenticationService
7520             && self.NullSession == other.NullSession
7521     }
7522 }
7523 #[cfg(feature = "Win32_Foundation")]
7524 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V1_W {}
7525 #[cfg(feature = "Win32_Foundation")]
7526 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V1_W {
7527     type Abi = Self;
7528     type DefaultType = Self;
7529 }
7530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7531 #[repr(C)]
7532 #[cfg(feature = "Win32_Foundation")]
7533 pub struct RPC_CALL_ATTRIBUTES_V2_A {
7534     pub Version: u32,
7535     pub Flags: u32,
7536     pub ServerPrincipalNameBufferLength: u32,
7537     pub ServerPrincipalName: *mut u8,
7538     pub ClientPrincipalNameBufferLength: u32,
7539     pub ClientPrincipalName: *mut u8,
7540     pub AuthenticationLevel: u32,
7541     pub AuthenticationService: u32,
7542     pub NullSession: super::super::Foundation::BOOL,
7543     pub KernelModeCaller: super::super::Foundation::BOOL,
7544     pub ProtocolSequence: u32,
7545     pub IsClientLocal: u32,
7546     pub ClientPID: super::super::Foundation::HANDLE,
7547     pub CallStatus: u32,
7548     pub CallType: RpcCallType,
7549     pub CallLocalAddress: *mut RPC_CALL_LOCAL_ADDRESS_V1,
7550     pub OpNum: u16,
7551     pub InterfaceUuid: ::windows::runtime::GUID,
7552 }
7553 #[cfg(feature = "Win32_Foundation")]
7554 impl RPC_CALL_ATTRIBUTES_V2_A {}
7555 #[cfg(feature = "Win32_Foundation")]
7556 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V2_A {
default() -> Self7557     fn default() -> Self {
7558         unsafe { ::std::mem::zeroed() }
7559     }
7560 }
7561 #[cfg(feature = "Win32_Foundation")]
7562 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V2_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7563     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7564         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V2_A")
7565             .field("Version", &self.Version)
7566             .field("Flags", &self.Flags)
7567             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7568             .field("ServerPrincipalName", &self.ServerPrincipalName)
7569             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7570             .field("ClientPrincipalName", &self.ClientPrincipalName)
7571             .field("AuthenticationLevel", &self.AuthenticationLevel)
7572             .field("AuthenticationService", &self.AuthenticationService)
7573             .field("NullSession", &self.NullSession)
7574             .field("KernelModeCaller", &self.KernelModeCaller)
7575             .field("ProtocolSequence", &self.ProtocolSequence)
7576             .field("IsClientLocal", &self.IsClientLocal)
7577             .field("ClientPID", &self.ClientPID)
7578             .field("CallStatus", &self.CallStatus)
7579             .field("CallType", &self.CallType)
7580             .field("CallLocalAddress", &self.CallLocalAddress)
7581             .field("OpNum", &self.OpNum)
7582             .field("InterfaceUuid", &self.InterfaceUuid)
7583             .finish()
7584     }
7585 }
7586 #[cfg(feature = "Win32_Foundation")]
7587 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V2_A {
eq(&self, other: &Self) -> bool7588     fn eq(&self, other: &Self) -> bool {
7589         self.Version == other.Version
7590             && self.Flags == other.Flags
7591             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7592             && self.ServerPrincipalName == other.ServerPrincipalName
7593             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7594             && self.ClientPrincipalName == other.ClientPrincipalName
7595             && self.AuthenticationLevel == other.AuthenticationLevel
7596             && self.AuthenticationService == other.AuthenticationService
7597             && self.NullSession == other.NullSession
7598             && self.KernelModeCaller == other.KernelModeCaller
7599             && self.ProtocolSequence == other.ProtocolSequence
7600             && self.IsClientLocal == other.IsClientLocal
7601             && self.ClientPID == other.ClientPID
7602             && self.CallStatus == other.CallStatus
7603             && self.CallType == other.CallType
7604             && self.CallLocalAddress == other.CallLocalAddress
7605             && self.OpNum == other.OpNum
7606             && self.InterfaceUuid == other.InterfaceUuid
7607     }
7608 }
7609 #[cfg(feature = "Win32_Foundation")]
7610 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V2_A {}
7611 #[cfg(feature = "Win32_Foundation")]
7612 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V2_A {
7613     type Abi = Self;
7614     type DefaultType = Self;
7615 }
7616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7617 #[repr(C)]
7618 #[cfg(feature = "Win32_Foundation")]
7619 pub struct RPC_CALL_ATTRIBUTES_V2_W {
7620     pub Version: u32,
7621     pub Flags: u32,
7622     pub ServerPrincipalNameBufferLength: u32,
7623     pub ServerPrincipalName: *mut u16,
7624     pub ClientPrincipalNameBufferLength: u32,
7625     pub ClientPrincipalName: *mut u16,
7626     pub AuthenticationLevel: u32,
7627     pub AuthenticationService: u32,
7628     pub NullSession: super::super::Foundation::BOOL,
7629     pub KernelModeCaller: super::super::Foundation::BOOL,
7630     pub ProtocolSequence: u32,
7631     pub IsClientLocal: RpcCallClientLocality,
7632     pub ClientPID: super::super::Foundation::HANDLE,
7633     pub CallStatus: u32,
7634     pub CallType: RpcCallType,
7635     pub CallLocalAddress: *mut RPC_CALL_LOCAL_ADDRESS_V1,
7636     pub OpNum: u16,
7637     pub InterfaceUuid: ::windows::runtime::GUID,
7638 }
7639 #[cfg(feature = "Win32_Foundation")]
7640 impl RPC_CALL_ATTRIBUTES_V2_W {}
7641 #[cfg(feature = "Win32_Foundation")]
7642 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V2_W {
default() -> Self7643     fn default() -> Self {
7644         unsafe { ::std::mem::zeroed() }
7645     }
7646 }
7647 #[cfg(feature = "Win32_Foundation")]
7648 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V2_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7649     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7650         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V2_W")
7651             .field("Version", &self.Version)
7652             .field("Flags", &self.Flags)
7653             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7654             .field("ServerPrincipalName", &self.ServerPrincipalName)
7655             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7656             .field("ClientPrincipalName", &self.ClientPrincipalName)
7657             .field("AuthenticationLevel", &self.AuthenticationLevel)
7658             .field("AuthenticationService", &self.AuthenticationService)
7659             .field("NullSession", &self.NullSession)
7660             .field("KernelModeCaller", &self.KernelModeCaller)
7661             .field("ProtocolSequence", &self.ProtocolSequence)
7662             .field("IsClientLocal", &self.IsClientLocal)
7663             .field("ClientPID", &self.ClientPID)
7664             .field("CallStatus", &self.CallStatus)
7665             .field("CallType", &self.CallType)
7666             .field("CallLocalAddress", &self.CallLocalAddress)
7667             .field("OpNum", &self.OpNum)
7668             .field("InterfaceUuid", &self.InterfaceUuid)
7669             .finish()
7670     }
7671 }
7672 #[cfg(feature = "Win32_Foundation")]
7673 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V2_W {
eq(&self, other: &Self) -> bool7674     fn eq(&self, other: &Self) -> bool {
7675         self.Version == other.Version
7676             && self.Flags == other.Flags
7677             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7678             && self.ServerPrincipalName == other.ServerPrincipalName
7679             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7680             && self.ClientPrincipalName == other.ClientPrincipalName
7681             && self.AuthenticationLevel == other.AuthenticationLevel
7682             && self.AuthenticationService == other.AuthenticationService
7683             && self.NullSession == other.NullSession
7684             && self.KernelModeCaller == other.KernelModeCaller
7685             && self.ProtocolSequence == other.ProtocolSequence
7686             && self.IsClientLocal == other.IsClientLocal
7687             && self.ClientPID == other.ClientPID
7688             && self.CallStatus == other.CallStatus
7689             && self.CallType == other.CallType
7690             && self.CallLocalAddress == other.CallLocalAddress
7691             && self.OpNum == other.OpNum
7692             && self.InterfaceUuid == other.InterfaceUuid
7693     }
7694 }
7695 #[cfg(feature = "Win32_Foundation")]
7696 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V2_W {}
7697 #[cfg(feature = "Win32_Foundation")]
7698 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V2_W {
7699     type Abi = Self;
7700     type DefaultType = Self;
7701 }
7702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7703 #[repr(C)]
7704 #[cfg(feature = "Win32_Foundation")]
7705 pub struct RPC_CALL_ATTRIBUTES_V3_A {
7706     pub Version: u32,
7707     pub Flags: u32,
7708     pub ServerPrincipalNameBufferLength: u32,
7709     pub ServerPrincipalName: *mut u8,
7710     pub ClientPrincipalNameBufferLength: u32,
7711     pub ClientPrincipalName: *mut u8,
7712     pub AuthenticationLevel: u32,
7713     pub AuthenticationService: u32,
7714     pub NullSession: super::super::Foundation::BOOL,
7715     pub KernelModeCaller: super::super::Foundation::BOOL,
7716     pub ProtocolSequence: u32,
7717     pub IsClientLocal: u32,
7718     pub ClientPID: super::super::Foundation::HANDLE,
7719     pub CallStatus: u32,
7720     pub CallType: RpcCallType,
7721     pub CallLocalAddress: *mut RPC_CALL_LOCAL_ADDRESS_V1,
7722     pub OpNum: u16,
7723     pub InterfaceUuid: ::windows::runtime::GUID,
7724     pub ClientIdentifierBufferLength: u32,
7725     pub ClientIdentifier: *mut u8,
7726 }
7727 #[cfg(feature = "Win32_Foundation")]
7728 impl RPC_CALL_ATTRIBUTES_V3_A {}
7729 #[cfg(feature = "Win32_Foundation")]
7730 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V3_A {
default() -> Self7731     fn default() -> Self {
7732         unsafe { ::std::mem::zeroed() }
7733     }
7734 }
7735 #[cfg(feature = "Win32_Foundation")]
7736 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V3_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7737     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7738         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V3_A")
7739             .field("Version", &self.Version)
7740             .field("Flags", &self.Flags)
7741             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7742             .field("ServerPrincipalName", &self.ServerPrincipalName)
7743             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7744             .field("ClientPrincipalName", &self.ClientPrincipalName)
7745             .field("AuthenticationLevel", &self.AuthenticationLevel)
7746             .field("AuthenticationService", &self.AuthenticationService)
7747             .field("NullSession", &self.NullSession)
7748             .field("KernelModeCaller", &self.KernelModeCaller)
7749             .field("ProtocolSequence", &self.ProtocolSequence)
7750             .field("IsClientLocal", &self.IsClientLocal)
7751             .field("ClientPID", &self.ClientPID)
7752             .field("CallStatus", &self.CallStatus)
7753             .field("CallType", &self.CallType)
7754             .field("CallLocalAddress", &self.CallLocalAddress)
7755             .field("OpNum", &self.OpNum)
7756             .field("InterfaceUuid", &self.InterfaceUuid)
7757             .field("ClientIdentifierBufferLength", &self.ClientIdentifierBufferLength)
7758             .field("ClientIdentifier", &self.ClientIdentifier)
7759             .finish()
7760     }
7761 }
7762 #[cfg(feature = "Win32_Foundation")]
7763 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V3_A {
eq(&self, other: &Self) -> bool7764     fn eq(&self, other: &Self) -> bool {
7765         self.Version == other.Version
7766             && self.Flags == other.Flags
7767             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7768             && self.ServerPrincipalName == other.ServerPrincipalName
7769             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7770             && self.ClientPrincipalName == other.ClientPrincipalName
7771             && self.AuthenticationLevel == other.AuthenticationLevel
7772             && self.AuthenticationService == other.AuthenticationService
7773             && self.NullSession == other.NullSession
7774             && self.KernelModeCaller == other.KernelModeCaller
7775             && self.ProtocolSequence == other.ProtocolSequence
7776             && self.IsClientLocal == other.IsClientLocal
7777             && self.ClientPID == other.ClientPID
7778             && self.CallStatus == other.CallStatus
7779             && self.CallType == other.CallType
7780             && self.CallLocalAddress == other.CallLocalAddress
7781             && self.OpNum == other.OpNum
7782             && self.InterfaceUuid == other.InterfaceUuid
7783             && self.ClientIdentifierBufferLength == other.ClientIdentifierBufferLength
7784             && self.ClientIdentifier == other.ClientIdentifier
7785     }
7786 }
7787 #[cfg(feature = "Win32_Foundation")]
7788 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V3_A {}
7789 #[cfg(feature = "Win32_Foundation")]
7790 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V3_A {
7791     type Abi = Self;
7792     type DefaultType = Self;
7793 }
7794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7795 #[repr(C)]
7796 #[cfg(feature = "Win32_Foundation")]
7797 pub struct RPC_CALL_ATTRIBUTES_V3_W {
7798     pub Version: u32,
7799     pub Flags: u32,
7800     pub ServerPrincipalNameBufferLength: u32,
7801     pub ServerPrincipalName: *mut u16,
7802     pub ClientPrincipalNameBufferLength: u32,
7803     pub ClientPrincipalName: *mut u16,
7804     pub AuthenticationLevel: u32,
7805     pub AuthenticationService: u32,
7806     pub NullSession: super::super::Foundation::BOOL,
7807     pub KernelModeCaller: super::super::Foundation::BOOL,
7808     pub ProtocolSequence: u32,
7809     pub IsClientLocal: RpcCallClientLocality,
7810     pub ClientPID: super::super::Foundation::HANDLE,
7811     pub CallStatus: u32,
7812     pub CallType: RpcCallType,
7813     pub CallLocalAddress: *mut RPC_CALL_LOCAL_ADDRESS_V1,
7814     pub OpNum: u16,
7815     pub InterfaceUuid: ::windows::runtime::GUID,
7816     pub ClientIdentifierBufferLength: u32,
7817     pub ClientIdentifier: *mut u8,
7818 }
7819 #[cfg(feature = "Win32_Foundation")]
7820 impl RPC_CALL_ATTRIBUTES_V3_W {}
7821 #[cfg(feature = "Win32_Foundation")]
7822 impl ::std::default::Default for RPC_CALL_ATTRIBUTES_V3_W {
default() -> Self7823     fn default() -> Self {
7824         unsafe { ::std::mem::zeroed() }
7825     }
7826 }
7827 #[cfg(feature = "Win32_Foundation")]
7828 impl ::std::fmt::Debug for RPC_CALL_ATTRIBUTES_V3_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7829     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7830         fmt.debug_struct("RPC_CALL_ATTRIBUTES_V3_W")
7831             .field("Version", &self.Version)
7832             .field("Flags", &self.Flags)
7833             .field("ServerPrincipalNameBufferLength", &self.ServerPrincipalNameBufferLength)
7834             .field("ServerPrincipalName", &self.ServerPrincipalName)
7835             .field("ClientPrincipalNameBufferLength", &self.ClientPrincipalNameBufferLength)
7836             .field("ClientPrincipalName", &self.ClientPrincipalName)
7837             .field("AuthenticationLevel", &self.AuthenticationLevel)
7838             .field("AuthenticationService", &self.AuthenticationService)
7839             .field("NullSession", &self.NullSession)
7840             .field("KernelModeCaller", &self.KernelModeCaller)
7841             .field("ProtocolSequence", &self.ProtocolSequence)
7842             .field("IsClientLocal", &self.IsClientLocal)
7843             .field("ClientPID", &self.ClientPID)
7844             .field("CallStatus", &self.CallStatus)
7845             .field("CallType", &self.CallType)
7846             .field("CallLocalAddress", &self.CallLocalAddress)
7847             .field("OpNum", &self.OpNum)
7848             .field("InterfaceUuid", &self.InterfaceUuid)
7849             .field("ClientIdentifierBufferLength", &self.ClientIdentifierBufferLength)
7850             .field("ClientIdentifier", &self.ClientIdentifier)
7851             .finish()
7852     }
7853 }
7854 #[cfg(feature = "Win32_Foundation")]
7855 impl ::std::cmp::PartialEq for RPC_CALL_ATTRIBUTES_V3_W {
eq(&self, other: &Self) -> bool7856     fn eq(&self, other: &Self) -> bool {
7857         self.Version == other.Version
7858             && self.Flags == other.Flags
7859             && self.ServerPrincipalNameBufferLength == other.ServerPrincipalNameBufferLength
7860             && self.ServerPrincipalName == other.ServerPrincipalName
7861             && self.ClientPrincipalNameBufferLength == other.ClientPrincipalNameBufferLength
7862             && self.ClientPrincipalName == other.ClientPrincipalName
7863             && self.AuthenticationLevel == other.AuthenticationLevel
7864             && self.AuthenticationService == other.AuthenticationService
7865             && self.NullSession == other.NullSession
7866             && self.KernelModeCaller == other.KernelModeCaller
7867             && self.ProtocolSequence == other.ProtocolSequence
7868             && self.IsClientLocal == other.IsClientLocal
7869             && self.ClientPID == other.ClientPID
7870             && self.CallStatus == other.CallStatus
7871             && self.CallType == other.CallType
7872             && self.CallLocalAddress == other.CallLocalAddress
7873             && self.OpNum == other.OpNum
7874             && self.InterfaceUuid == other.InterfaceUuid
7875             && self.ClientIdentifierBufferLength == other.ClientIdentifierBufferLength
7876             && self.ClientIdentifier == other.ClientIdentifier
7877     }
7878 }
7879 #[cfg(feature = "Win32_Foundation")]
7880 impl ::std::cmp::Eq for RPC_CALL_ATTRIBUTES_V3_W {}
7881 #[cfg(feature = "Win32_Foundation")]
7882 unsafe impl ::windows::runtime::Abi for RPC_CALL_ATTRIBUTES_V3_W {
7883     type Abi = Self;
7884     type DefaultType = Self;
7885 }
7886 pub const RPC_CALL_ATTRIBUTES_VERSION: u32 = 2u32;
7887 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7888 #[repr(C)]
7889 pub struct RPC_CALL_LOCAL_ADDRESS_V1 {
7890     pub Version: u32,
7891     pub Buffer: *mut ::std::ffi::c_void,
7892     pub BufferSize: u32,
7893     pub AddressFormat: RpcLocalAddressFormat,
7894 }
7895 impl RPC_CALL_LOCAL_ADDRESS_V1 {}
7896 impl ::std::default::Default for RPC_CALL_LOCAL_ADDRESS_V1 {
default() -> Self7897     fn default() -> Self {
7898         unsafe { ::std::mem::zeroed() }
7899     }
7900 }
7901 impl ::std::fmt::Debug for RPC_CALL_LOCAL_ADDRESS_V1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7902     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7903         fmt.debug_struct("RPC_CALL_LOCAL_ADDRESS_V1").field("Version", &self.Version).field("Buffer", &self.Buffer).field("BufferSize", &self.BufferSize).field("AddressFormat", &self.AddressFormat).finish()
7904     }
7905 }
7906 impl ::std::cmp::PartialEq for RPC_CALL_LOCAL_ADDRESS_V1 {
eq(&self, other: &Self) -> bool7907     fn eq(&self, other: &Self) -> bool {
7908         self.Version == other.Version && self.Buffer == other.Buffer && self.BufferSize == other.BufferSize && self.AddressFormat == other.AddressFormat
7909     }
7910 }
7911 impl ::std::cmp::Eq for RPC_CALL_LOCAL_ADDRESS_V1 {}
7912 unsafe impl ::windows::runtime::Abi for RPC_CALL_LOCAL_ADDRESS_V1 {
7913     type Abi = Self;
7914     type DefaultType = Self;
7915 }
7916 pub const RPC_CALL_STATUS_CANCELLED: u32 = 1u32;
7917 pub const RPC_CALL_STATUS_DISCONNECTED: u32 = 2u32;
7918 pub type RPC_CLIENT_ALLOC = unsafe extern "system" fn(size: usize) -> *mut ::std::ffi::c_void;
7919 pub type RPC_CLIENT_FREE = unsafe extern "system" fn(ptr: *const ::std::ffi::c_void);
7920 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7921 #[repr(C)]
7922 pub struct RPC_CLIENT_INFORMATION1 {
7923     pub UserName: *mut u8,
7924     pub ComputerName: *mut u8,
7925     pub Privilege: u16,
7926     pub AuthFlags: u32,
7927 }
7928 impl RPC_CLIENT_INFORMATION1 {}
7929 impl ::std::default::Default for RPC_CLIENT_INFORMATION1 {
default() -> Self7930     fn default() -> Self {
7931         unsafe { ::std::mem::zeroed() }
7932     }
7933 }
7934 impl ::std::fmt::Debug for RPC_CLIENT_INFORMATION1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7935     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7936         fmt.debug_struct("RPC_CLIENT_INFORMATION1").field("UserName", &self.UserName).field("ComputerName", &self.ComputerName).field("Privilege", &self.Privilege).field("AuthFlags", &self.AuthFlags).finish()
7937     }
7938 }
7939 impl ::std::cmp::PartialEq for RPC_CLIENT_INFORMATION1 {
eq(&self, other: &Self) -> bool7940     fn eq(&self, other: &Self) -> bool {
7941         self.UserName == other.UserName && self.ComputerName == other.ComputerName && self.Privilege == other.Privilege && self.AuthFlags == other.AuthFlags
7942     }
7943 }
7944 impl ::std::cmp::Eq for RPC_CLIENT_INFORMATION1 {}
7945 unsafe impl ::windows::runtime::Abi for RPC_CLIENT_INFORMATION1 {
7946     type Abi = Self;
7947     type DefaultType = Self;
7948 }
7949 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7950 #[repr(C)]
7951 pub struct RPC_CLIENT_INTERFACE {
7952     pub Length: u32,
7953     pub InterfaceId: RPC_SYNTAX_IDENTIFIER,
7954     pub TransferSyntax: RPC_SYNTAX_IDENTIFIER,
7955     pub DispatchTable: *mut RPC_DISPATCH_TABLE,
7956     pub RpcProtseqEndpointCount: u32,
7957     pub RpcProtseqEndpoint: *mut RPC_PROTSEQ_ENDPOINT,
7958     pub Reserved: usize,
7959     pub InterpreterInfo: *mut ::std::ffi::c_void,
7960     pub Flags: u32,
7961 }
7962 impl RPC_CLIENT_INTERFACE {}
7963 impl ::std::default::Default for RPC_CLIENT_INTERFACE {
default() -> Self7964     fn default() -> Self {
7965         unsafe { ::std::mem::zeroed() }
7966     }
7967 }
7968 impl ::std::fmt::Debug for RPC_CLIENT_INTERFACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7969     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7970         fmt.debug_struct("RPC_CLIENT_INTERFACE")
7971             .field("Length", &self.Length)
7972             .field("InterfaceId", &self.InterfaceId)
7973             .field("TransferSyntax", &self.TransferSyntax)
7974             .field("DispatchTable", &self.DispatchTable)
7975             .field("RpcProtseqEndpointCount", &self.RpcProtseqEndpointCount)
7976             .field("RpcProtseqEndpoint", &self.RpcProtseqEndpoint)
7977             .field("Reserved", &self.Reserved)
7978             .field("InterpreterInfo", &self.InterpreterInfo)
7979             .field("Flags", &self.Flags)
7980             .finish()
7981     }
7982 }
7983 impl ::std::cmp::PartialEq for RPC_CLIENT_INTERFACE {
eq(&self, other: &Self) -> bool7984     fn eq(&self, other: &Self) -> bool {
7985         self.Length == other.Length && self.InterfaceId == other.InterfaceId && self.TransferSyntax == other.TransferSyntax && self.DispatchTable == other.DispatchTable && self.RpcProtseqEndpointCount == other.RpcProtseqEndpointCount && self.RpcProtseqEndpoint == other.RpcProtseqEndpoint && self.Reserved == other.Reserved && self.InterpreterInfo == other.InterpreterInfo && self.Flags == other.Flags
7986     }
7987 }
7988 impl ::std::cmp::Eq for RPC_CLIENT_INTERFACE {}
7989 unsafe impl ::windows::runtime::Abi for RPC_CLIENT_INTERFACE {
7990     type Abi = Self;
7991     type DefaultType = Self;
7992 }
7993 pub const RPC_CONTEXT_HANDLE_DEFAULT_FLAGS: u32 = 0u32;
7994 pub const RPC_CONTEXT_HANDLE_DONT_SERIALIZE: u32 = 536870912u32;
7995 pub const RPC_CONTEXT_HANDLE_FLAGS: u32 = 805306368u32;
7996 pub const RPC_CONTEXT_HANDLE_SERIALIZE: u32 = 268435456u32;
7997 pub const RPC_C_AUTHN_CLOUD_AP: u32 = 36u32;
7998 pub const RPC_C_AUTHN_DCE_PRIVATE: u32 = 1u32;
7999 pub const RPC_C_AUTHN_DCE_PUBLIC: u32 = 2u32;
8000 pub const RPC_C_AUTHN_DEC_PUBLIC: u32 = 4u32;
8001 pub const RPC_C_AUTHN_DEFAULT: i32 = -1i32;
8002 pub const RPC_C_AUTHN_DIGEST: u32 = 21u32;
8003 pub const RPC_C_AUTHN_DPA: u32 = 17u32;
8004 pub const RPC_C_AUTHN_GSS_KERBEROS: u32 = 16u32;
8005 pub const RPC_C_AUTHN_GSS_NEGOTIATE: u32 = 9u32;
8006 pub const RPC_C_AUTHN_GSS_SCHANNEL: u32 = 14u32;
8007 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8008 #[repr(transparent)]
8009 pub struct RPC_C_AUTHN_INFO_TYPE(pub u32);
8010 pub const RPC_C_AUTHN_INFO_NONE: RPC_C_AUTHN_INFO_TYPE = RPC_C_AUTHN_INFO_TYPE(0u32);
8011 pub const RPC_C_AUTHN_INFO_TYPE_HTTP: RPC_C_AUTHN_INFO_TYPE = RPC_C_AUTHN_INFO_TYPE(1u32);
8012 impl ::std::convert::From<u32> for RPC_C_AUTHN_INFO_TYPE {
from(value: u32) -> Self8013     fn from(value: u32) -> Self {
8014         Self(value)
8015     }
8016 }
8017 unsafe impl ::windows::runtime::Abi for RPC_C_AUTHN_INFO_TYPE {
8018     type Abi = Self;
8019     type DefaultType = Self;
8020 }
8021 impl ::std::ops::BitOr for RPC_C_AUTHN_INFO_TYPE {
8022     type Output = Self;
bitor(self, rhs: Self) -> Self8023     fn bitor(self, rhs: Self) -> Self {
8024         Self(self.0 | rhs.0)
8025     }
8026 }
8027 impl ::std::ops::BitAnd for RPC_C_AUTHN_INFO_TYPE {
8028     type Output = Self;
bitand(self, rhs: Self) -> Self8029     fn bitand(self, rhs: Self) -> Self {
8030         Self(self.0 & rhs.0)
8031     }
8032 }
8033 impl ::std::ops::BitOrAssign for RPC_C_AUTHN_INFO_TYPE {
bitor_assign(&mut self, rhs: Self)8034     fn bitor_assign(&mut self, rhs: Self) {
8035         self.0.bitor_assign(rhs.0)
8036     }
8037 }
8038 impl ::std::ops::BitAndAssign for RPC_C_AUTHN_INFO_TYPE {
bitand_assign(&mut self, rhs: Self)8039     fn bitand_assign(&mut self, rhs: Self) {
8040         self.0.bitand_assign(rhs.0)
8041     }
8042 }
8043 impl ::std::ops::Not for RPC_C_AUTHN_INFO_TYPE {
8044     type Output = Self;
not(self) -> Self8045     fn not(self) -> Self {
8046         Self(self.0.not())
8047     }
8048 }
8049 pub const RPC_C_AUTHN_KERNEL: u32 = 20u32;
8050 pub const RPC_C_AUTHN_LIVEXP_SSP: u32 = 35u32;
8051 pub const RPC_C_AUTHN_LIVE_SSP: u32 = 32u32;
8052 pub const RPC_C_AUTHN_MQ: u32 = 100u32;
8053 pub const RPC_C_AUTHN_MSN: u32 = 18u32;
8054 pub const RPC_C_AUTHN_MSONLINE: u32 = 82u32;
8055 pub const RPC_C_AUTHN_NEGO_EXTENDER: u32 = 30u32;
8056 pub const RPC_C_AUTHN_NONE: u32 = 0u32;
8057 pub const RPC_C_AUTHN_PKU2U: u32 = 31u32;
8058 pub const RPC_C_AUTHN_WINNT: u32 = 10u32;
8059 pub const RPC_C_AUTHZ_DCE: u32 = 2u32;
8060 pub const RPC_C_AUTHZ_DEFAULT: u32 = 4294967295u32;
8061 pub const RPC_C_AUTHZ_NAME: u32 = 1u32;
8062 pub const RPC_C_AUTHZ_NONE: u32 = 0u32;
8063 pub const RPC_C_BINDING_DEFAULT_TIMEOUT: u32 = 5u32;
8064 pub const RPC_C_BINDING_INFINITE_TIMEOUT: u32 = 10u32;
8065 pub const RPC_C_BINDING_MAX_TIMEOUT: u32 = 9u32;
8066 pub const RPC_C_BINDING_MIN_TIMEOUT: u32 = 0u32;
8067 pub const RPC_C_BIND_TO_ALL_NICS: u32 = 1u32;
8068 pub const RPC_C_CANCEL_INFINITE_TIMEOUT: i32 = -1i32;
8069 pub const RPC_C_DONT_FAIL: u32 = 4u32;
8070 pub const RPC_C_EP_ALL_ELTS: u32 = 0u32;
8071 pub const RPC_C_EP_MATCH_BY_BOTH: u32 = 3u32;
8072 pub const RPC_C_EP_MATCH_BY_IF: u32 = 1u32;
8073 pub const RPC_C_EP_MATCH_BY_OBJ: u32 = 2u32;
8074 pub const RPC_C_FULL_CERT_CHAIN: u32 = 1u32;
8075 pub const RPC_C_HTTP_AUTHN_SCHEME_BASIC: u32 = 1u32;
8076 pub const RPC_C_HTTP_AUTHN_SCHEME_CERT: u32 = 65536u32;
8077 pub const RPC_C_HTTP_AUTHN_SCHEME_DIGEST: u32 = 8u32;
8078 pub const RPC_C_HTTP_AUTHN_SCHEME_NEGOTIATE: u32 = 16u32;
8079 pub const RPC_C_HTTP_AUTHN_SCHEME_NTLM: u32 = 2u32;
8080 pub const RPC_C_HTTP_AUTHN_SCHEME_PASSPORT: u32 = 4u32;
8081 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8082 #[repr(transparent)]
8083 pub struct RPC_C_HTTP_AUTHN_TARGET(pub u32);
8084 pub const RPC_C_HTTP_AUTHN_TARGET_SERVER: RPC_C_HTTP_AUTHN_TARGET = RPC_C_HTTP_AUTHN_TARGET(1u32);
8085 pub const RPC_C_HTTP_AUTHN_TARGET_PROXY: RPC_C_HTTP_AUTHN_TARGET = RPC_C_HTTP_AUTHN_TARGET(2u32);
8086 impl ::std::convert::From<u32> for RPC_C_HTTP_AUTHN_TARGET {
from(value: u32) -> Self8087     fn from(value: u32) -> Self {
8088         Self(value)
8089     }
8090 }
8091 unsafe impl ::windows::runtime::Abi for RPC_C_HTTP_AUTHN_TARGET {
8092     type Abi = Self;
8093     type DefaultType = Self;
8094 }
8095 impl ::std::ops::BitOr for RPC_C_HTTP_AUTHN_TARGET {
8096     type Output = Self;
bitor(self, rhs: Self) -> Self8097     fn bitor(self, rhs: Self) -> Self {
8098         Self(self.0 | rhs.0)
8099     }
8100 }
8101 impl ::std::ops::BitAnd for RPC_C_HTTP_AUTHN_TARGET {
8102     type Output = Self;
bitand(self, rhs: Self) -> Self8103     fn bitand(self, rhs: Self) -> Self {
8104         Self(self.0 & rhs.0)
8105     }
8106 }
8107 impl ::std::ops::BitOrAssign for RPC_C_HTTP_AUTHN_TARGET {
bitor_assign(&mut self, rhs: Self)8108     fn bitor_assign(&mut self, rhs: Self) {
8109         self.0.bitor_assign(rhs.0)
8110     }
8111 }
8112 impl ::std::ops::BitAndAssign for RPC_C_HTTP_AUTHN_TARGET {
bitand_assign(&mut self, rhs: Self)8113     fn bitand_assign(&mut self, rhs: Self) {
8114         self.0.bitand_assign(rhs.0)
8115     }
8116 }
8117 impl ::std::ops::Not for RPC_C_HTTP_AUTHN_TARGET {
8118     type Output = Self;
not(self) -> Self8119     fn not(self) -> Self {
8120         Self(self.0.not())
8121     }
8122 }
8123 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8124 #[repr(transparent)]
8125 pub struct RPC_C_HTTP_FLAGS(pub u32);
8126 pub const RPC_C_HTTP_FLAG_USE_SSL: RPC_C_HTTP_FLAGS = RPC_C_HTTP_FLAGS(1u32);
8127 pub const RPC_C_HTTP_FLAG_USE_FIRST_AUTH_SCHEME: RPC_C_HTTP_FLAGS = RPC_C_HTTP_FLAGS(2u32);
8128 pub const RPC_C_HTTP_FLAG_IGNORE_CERT_CN_INVALID: RPC_C_HTTP_FLAGS = RPC_C_HTTP_FLAGS(8u32);
8129 pub const RPC_C_HTTP_FLAG_ENABLE_CERT_REVOCATION_CHECK: RPC_C_HTTP_FLAGS = RPC_C_HTTP_FLAGS(16u32);
8130 impl ::std::convert::From<u32> for RPC_C_HTTP_FLAGS {
from(value: u32) -> Self8131     fn from(value: u32) -> Self {
8132         Self(value)
8133     }
8134 }
8135 unsafe impl ::windows::runtime::Abi for RPC_C_HTTP_FLAGS {
8136     type Abi = Self;
8137     type DefaultType = Self;
8138 }
8139 impl ::std::ops::BitOr for RPC_C_HTTP_FLAGS {
8140     type Output = Self;
bitor(self, rhs: Self) -> Self8141     fn bitor(self, rhs: Self) -> Self {
8142         Self(self.0 | rhs.0)
8143     }
8144 }
8145 impl ::std::ops::BitAnd for RPC_C_HTTP_FLAGS {
8146     type Output = Self;
bitand(self, rhs: Self) -> Self8147     fn bitand(self, rhs: Self) -> Self {
8148         Self(self.0 & rhs.0)
8149     }
8150 }
8151 impl ::std::ops::BitOrAssign for RPC_C_HTTP_FLAGS {
bitor_assign(&mut self, rhs: Self)8152     fn bitor_assign(&mut self, rhs: Self) {
8153         self.0.bitor_assign(rhs.0)
8154     }
8155 }
8156 impl ::std::ops::BitAndAssign for RPC_C_HTTP_FLAGS {
bitand_assign(&mut self, rhs: Self)8157     fn bitand_assign(&mut self, rhs: Self) {
8158         self.0.bitand_assign(rhs.0)
8159     }
8160 }
8161 impl ::std::ops::Not for RPC_C_HTTP_FLAGS {
8162     type Output = Self;
not(self) -> Self8163     fn not(self) -> Self {
8164         Self(self.0.not())
8165     }
8166 }
8167 pub const RPC_C_LISTEN_MAX_CALLS_DEFAULT: u32 = 1234u32;
8168 pub const RPC_C_MGMT_INQ_IF_IDS: u32 = 0u32;
8169 pub const RPC_C_MGMT_INQ_PRINC_NAME: u32 = 1u32;
8170 pub const RPC_C_MGMT_INQ_STATS: u32 = 2u32;
8171 pub const RPC_C_MGMT_IS_SERVER_LISTEN: u32 = 3u32;
8172 pub const RPC_C_MGMT_STOP_SERVER_LISTEN: u32 = 4u32;
8173 pub const RPC_C_MQ_AUTHN_LEVEL_NONE: u32 = 0u32;
8174 pub const RPC_C_MQ_AUTHN_LEVEL_PKT_INTEGRITY: u32 = 8u32;
8175 pub const RPC_C_MQ_AUTHN_LEVEL_PKT_PRIVACY: u32 = 16u32;
8176 pub const RPC_C_MQ_CLEAR_ON_OPEN: u32 = 2u32;
8177 pub const RPC_C_MQ_EXPRESS: u32 = 0u32;
8178 pub const RPC_C_MQ_JOURNAL_ALWAYS: u32 = 2u32;
8179 pub const RPC_C_MQ_JOURNAL_DEADLETTER: u32 = 1u32;
8180 pub const RPC_C_MQ_JOURNAL_NONE: u32 = 0u32;
8181 pub const RPC_C_MQ_PERMANENT: u32 = 1u32;
8182 pub const RPC_C_MQ_RECOVERABLE: u32 = 1u32;
8183 pub const RPC_C_MQ_TEMPORARY: u32 = 0u32;
8184 pub const RPC_C_MQ_USE_EXISTING_SECURITY: u32 = 4u32;
8185 pub const RPC_C_NOTIFY_ON_SEND_COMPLETE: u32 = 1u32;
8186 pub const RPC_C_NS_DEFAULT_EXP_AGE: i32 = -1i32;
8187 pub const RPC_C_OPT_ASYNC_BLOCK: u32 = 15u32;
8188 pub const RPC_C_OPT_BINDING_NONCAUSAL: u32 = 9u32;
8189 pub const RPC_C_OPT_CALL_TIMEOUT: u32 = 12u32;
8190 pub const RPC_C_OPT_COOKIE_AUTH: u32 = 7u32;
8191 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8192 #[repr(C)]
8193 #[cfg(feature = "Win32_Foundation")]
8194 pub struct RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {
8195     pub BufferSize: u32,
8196     pub Buffer: super::super::Foundation::PSTR,
8197 }
8198 #[cfg(feature = "Win32_Foundation")]
8199 impl RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {}
8200 #[cfg(feature = "Win32_Foundation")]
8201 impl ::std::default::Default for RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {
default() -> Self8202     fn default() -> Self {
8203         unsafe { ::std::mem::zeroed() }
8204     }
8205 }
8206 #[cfg(feature = "Win32_Foundation")]
8207 impl ::std::fmt::Debug for RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8208     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8209         fmt.debug_struct("RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR").field("BufferSize", &self.BufferSize).field("Buffer", &self.Buffer).finish()
8210     }
8211 }
8212 #[cfg(feature = "Win32_Foundation")]
8213 impl ::std::cmp::PartialEq for RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {
eq(&self, other: &Self) -> bool8214     fn eq(&self, other: &Self) -> bool {
8215         self.BufferSize == other.BufferSize && self.Buffer == other.Buffer
8216     }
8217 }
8218 #[cfg(feature = "Win32_Foundation")]
8219 impl ::std::cmp::Eq for RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {}
8220 #[cfg(feature = "Win32_Foundation")]
8221 unsafe impl ::windows::runtime::Abi for RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR {
8222     type Abi = Self;
8223     type DefaultType = Self;
8224 }
8225 pub const RPC_C_OPT_DONT_LINGER: u32 = 13u32;
8226 pub const RPC_C_OPT_MAX_OPTIONS: u32 = 12u32;
8227 pub const RPC_C_OPT_MQ_ACKNOWLEDGE: u32 = 4u32;
8228 pub const RPC_C_OPT_MQ_AUTHN_LEVEL: u32 = 6u32;
8229 pub const RPC_C_OPT_MQ_AUTHN_SERVICE: u32 = 5u32;
8230 pub const RPC_C_OPT_MQ_DELIVERY: u32 = 1u32;
8231 pub const RPC_C_OPT_MQ_JOURNAL: u32 = 3u32;
8232 pub const RPC_C_OPT_MQ_PRIORITY: u32 = 2u32;
8233 pub const RPC_C_OPT_MQ_TIME_TO_BE_RECEIVED: u32 = 8u32;
8234 pub const RPC_C_OPT_MQ_TIME_TO_REACH_QUEUE: u32 = 7u32;
8235 pub const RPC_C_OPT_OPTIMIZE_TIME: u32 = 16u32;
8236 pub const RPC_C_OPT_PRIVATE_BREAK_ON_SUSPEND: u32 = 3u32;
8237 pub const RPC_C_OPT_PRIVATE_DO_NOT_DISTURB: u32 = 2u32;
8238 pub const RPC_C_OPT_PRIVATE_SUPPRESS_WAKE: u32 = 1u32;
8239 pub const RPC_C_OPT_RESOURCE_TYPE_UUID: u32 = 8u32;
8240 pub const RPC_C_OPT_SECURITY_CALLBACK: u32 = 10u32;
8241 pub const RPC_C_OPT_SESSION_ID: u32 = 6u32;
8242 pub const RPC_C_OPT_TRANS_SEND_BUFFER_SIZE: u32 = 5u32;
8243 pub const RPC_C_OPT_TRUST_PEER: u32 = 14u32;
8244 pub const RPC_C_OPT_UNIQUE_BINDING: u32 = 11u32;
8245 pub const RPC_C_PARM_BUFFER_LENGTH: u32 = 2u32;
8246 pub const RPC_C_PARM_MAX_PACKET_LENGTH: u32 = 1u32;
8247 pub const RPC_C_PROFILE_ALL_ELT: u32 = 1u32;
8248 pub const RPC_C_PROFILE_ALL_ELTS: u32 = 1u32;
8249 pub const RPC_C_PROFILE_DEFAULT_ELT: u32 = 0u32;
8250 pub const RPC_C_PROFILE_MATCH_BY_BOTH: u32 = 4u32;
8251 pub const RPC_C_PROFILE_MATCH_BY_IF: u32 = 2u32;
8252 pub const RPC_C_PROFILE_MATCH_BY_MBR: u32 = 3u32;
8253 pub const RPC_C_PROTSEQ_MAX_REQS_DEFAULT: u32 = 10u32;
8254 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8255 #[repr(transparent)]
8256 pub struct RPC_C_QOS_CAPABILITIES(pub u32);
8257 pub const RPC_C_QOS_CAPABILITIES_DEFAULT: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(0u32);
8258 pub const RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(1u32);
8259 pub const RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(2u32);
8260 pub const RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(4u32);
8261 pub const RPC_C_QOS_CAPABILITIES_IGNORE_DELEGATE_FAILURE: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(8u32);
8262 pub const RPC_C_QOS_CAPABILITIES_LOCAL_MA_HINT: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(16u32);
8263 pub const RPC_C_QOS_CAPABILITIES_SCHANNEL_FULL_AUTH_IDENTITY: RPC_C_QOS_CAPABILITIES = RPC_C_QOS_CAPABILITIES(32u32);
8264 impl ::std::convert::From<u32> for RPC_C_QOS_CAPABILITIES {
from(value: u32) -> Self8265     fn from(value: u32) -> Self {
8266         Self(value)
8267     }
8268 }
8269 unsafe impl ::windows::runtime::Abi for RPC_C_QOS_CAPABILITIES {
8270     type Abi = Self;
8271     type DefaultType = Self;
8272 }
8273 impl ::std::ops::BitOr for RPC_C_QOS_CAPABILITIES {
8274     type Output = Self;
bitor(self, rhs: Self) -> Self8275     fn bitor(self, rhs: Self) -> Self {
8276         Self(self.0 | rhs.0)
8277     }
8278 }
8279 impl ::std::ops::BitAnd for RPC_C_QOS_CAPABILITIES {
8280     type Output = Self;
bitand(self, rhs: Self) -> Self8281     fn bitand(self, rhs: Self) -> Self {
8282         Self(self.0 & rhs.0)
8283     }
8284 }
8285 impl ::std::ops::BitOrAssign for RPC_C_QOS_CAPABILITIES {
bitor_assign(&mut self, rhs: Self)8286     fn bitor_assign(&mut self, rhs: Self) {
8287         self.0.bitor_assign(rhs.0)
8288     }
8289 }
8290 impl ::std::ops::BitAndAssign for RPC_C_QOS_CAPABILITIES {
bitand_assign(&mut self, rhs: Self)8291     fn bitand_assign(&mut self, rhs: Self) {
8292         self.0.bitand_assign(rhs.0)
8293     }
8294 }
8295 impl ::std::ops::Not for RPC_C_QOS_CAPABILITIES {
8296     type Output = Self;
not(self) -> Self8297     fn not(self) -> Self {
8298         Self(self.0.not())
8299     }
8300 }
8301 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8302 #[repr(transparent)]
8303 pub struct RPC_C_QOS_IDENTITY(pub u32);
8304 pub const RPC_C_QOS_IDENTITY_STATIC: RPC_C_QOS_IDENTITY = RPC_C_QOS_IDENTITY(0u32);
8305 pub const RPC_C_QOS_IDENTITY_DYNAMIC: RPC_C_QOS_IDENTITY = RPC_C_QOS_IDENTITY(1u32);
8306 impl ::std::convert::From<u32> for RPC_C_QOS_IDENTITY {
from(value: u32) -> Self8307     fn from(value: u32) -> Self {
8308         Self(value)
8309     }
8310 }
8311 unsafe impl ::windows::runtime::Abi for RPC_C_QOS_IDENTITY {
8312     type Abi = Self;
8313     type DefaultType = Self;
8314 }
8315 impl ::std::ops::BitOr for RPC_C_QOS_IDENTITY {
8316     type Output = Self;
bitor(self, rhs: Self) -> Self8317     fn bitor(self, rhs: Self) -> Self {
8318         Self(self.0 | rhs.0)
8319     }
8320 }
8321 impl ::std::ops::BitAnd for RPC_C_QOS_IDENTITY {
8322     type Output = Self;
bitand(self, rhs: Self) -> Self8323     fn bitand(self, rhs: Self) -> Self {
8324         Self(self.0 & rhs.0)
8325     }
8326 }
8327 impl ::std::ops::BitOrAssign for RPC_C_QOS_IDENTITY {
bitor_assign(&mut self, rhs: Self)8328     fn bitor_assign(&mut self, rhs: Self) {
8329         self.0.bitor_assign(rhs.0)
8330     }
8331 }
8332 impl ::std::ops::BitAndAssign for RPC_C_QOS_IDENTITY {
bitand_assign(&mut self, rhs: Self)8333     fn bitand_assign(&mut self, rhs: Self) {
8334         self.0.bitand_assign(rhs.0)
8335     }
8336 }
8337 impl ::std::ops::Not for RPC_C_QOS_IDENTITY {
8338     type Output = Self;
not(self) -> Self8339     fn not(self) -> Self {
8340         Self(self.0.not())
8341     }
8342 }
8343 pub const RPC_C_RPCHTTP_USE_LOAD_BALANCE: u32 = 8u32;
8344 pub const RPC_C_SECURITY_QOS_VERSION: i32 = 1i32;
8345 pub const RPC_C_SECURITY_QOS_VERSION_1: i32 = 1i32;
8346 pub const RPC_C_SECURITY_QOS_VERSION_2: i32 = 2i32;
8347 pub const RPC_C_SECURITY_QOS_VERSION_3: i32 = 3i32;
8348 pub const RPC_C_SECURITY_QOS_VERSION_4: i32 = 4i32;
8349 pub const RPC_C_SECURITY_QOS_VERSION_5: i32 = 5i32;
8350 pub const RPC_C_STATS_CALLS_IN: u32 = 0u32;
8351 pub const RPC_C_STATS_CALLS_OUT: u32 = 1u32;
8352 pub const RPC_C_STATS_PKTS_IN: u32 = 2u32;
8353 pub const RPC_C_STATS_PKTS_OUT: u32 = 3u32;
8354 pub const RPC_C_TRY_ENFORCE_MAX_CALLS: u32 = 16u32;
8355 pub const RPC_C_USE_INTERNET_PORT: u32 = 1u32;
8356 pub const RPC_C_USE_INTRANET_PORT: u32 = 2u32;
8357 pub const RPC_C_VERS_ALL: u32 = 1u32;
8358 pub const RPC_C_VERS_COMPATIBLE: u32 = 2u32;
8359 pub const RPC_C_VERS_EXACT: u32 = 3u32;
8360 pub const RPC_C_VERS_MAJOR_ONLY: u32 = 4u32;
8361 pub const RPC_C_VERS_UPTO: u32 = 5u32;
8362 pub type RPC_DISPATCH_FUNCTION = unsafe extern "system" fn(message: *mut RPC_MESSAGE);
8363 #[derive(:: std :: clone :: Clone)]
8364 #[repr(C)]
8365 pub struct RPC_DISPATCH_TABLE {
8366     pub DispatchTableCount: u32,
8367     pub DispatchTable: ::std::option::Option<RPC_DISPATCH_FUNCTION>,
8368     pub Reserved: isize,
8369 }
8370 impl RPC_DISPATCH_TABLE {}
8371 impl ::std::default::Default for RPC_DISPATCH_TABLE {
default() -> Self8372     fn default() -> Self {
8373         unsafe { ::std::mem::zeroed() }
8374     }
8375 }
8376 impl ::std::fmt::Debug for RPC_DISPATCH_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8377     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8378         fmt.debug_struct("RPC_DISPATCH_TABLE").field("DispatchTableCount", &self.DispatchTableCount).field("Reserved", &self.Reserved).finish()
8379     }
8380 }
8381 impl ::std::cmp::PartialEq for RPC_DISPATCH_TABLE {
eq(&self, other: &Self) -> bool8382     fn eq(&self, other: &Self) -> bool {
8383         self.DispatchTableCount == other.DispatchTableCount && self.DispatchTable.map(|f| f as usize) == other.DispatchTable.map(|f| f as usize) && self.Reserved == other.Reserved
8384     }
8385 }
8386 impl ::std::cmp::Eq for RPC_DISPATCH_TABLE {}
8387 unsafe impl ::windows::runtime::Abi for RPC_DISPATCH_TABLE {
8388     type Abi = ::std::mem::ManuallyDrop<Self>;
8389     type DefaultType = Self;
8390 }
8391 pub const RPC_EEINFO_VERSION: u32 = 1u32;
8392 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8393 #[repr(C)]
8394 #[cfg(feature = "Win32_Foundation")]
8395 pub struct RPC_EE_INFO_PARAM {
8396     pub ParameterType: ExtendedErrorParamTypes,
8397     pub u: RPC_EE_INFO_PARAM_0,
8398 }
8399 #[cfg(feature = "Win32_Foundation")]
8400 impl RPC_EE_INFO_PARAM {}
8401 #[cfg(feature = "Win32_Foundation")]
8402 impl ::std::default::Default for RPC_EE_INFO_PARAM {
default() -> Self8403     fn default() -> Self {
8404         unsafe { ::std::mem::zeroed() }
8405     }
8406 }
8407 #[cfg(feature = "Win32_Foundation")]
8408 impl ::std::cmp::PartialEq for RPC_EE_INFO_PARAM {
eq(&self, _other: &Self) -> bool8409     fn eq(&self, _other: &Self) -> bool {
8410         unimplemented!()
8411     }
8412 }
8413 #[cfg(feature = "Win32_Foundation")]
8414 impl ::std::cmp::Eq for RPC_EE_INFO_PARAM {}
8415 #[cfg(feature = "Win32_Foundation")]
8416 unsafe impl ::windows::runtime::Abi for RPC_EE_INFO_PARAM {
8417     type Abi = Self;
8418     type DefaultType = Self;
8419 }
8420 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8421 #[repr(C)]
8422 #[cfg(feature = "Win32_Foundation")]
8423 pub union RPC_EE_INFO_PARAM_0 {
8424     pub AnsiString: super::super::Foundation::PSTR,
8425     pub UnicodeString: super::super::Foundation::PWSTR,
8426     pub LVal: i32,
8427     pub SVal: i16,
8428     pub PVal: u64,
8429     pub BVal: BinaryParam,
8430 }
8431 #[cfg(feature = "Win32_Foundation")]
8432 impl RPC_EE_INFO_PARAM_0 {}
8433 #[cfg(feature = "Win32_Foundation")]
8434 impl ::std::default::Default for RPC_EE_INFO_PARAM_0 {
default() -> Self8435     fn default() -> Self {
8436         unsafe { ::std::mem::zeroed() }
8437     }
8438 }
8439 #[cfg(feature = "Win32_Foundation")]
8440 impl ::std::cmp::PartialEq for RPC_EE_INFO_PARAM_0 {
eq(&self, _other: &Self) -> bool8441     fn eq(&self, _other: &Self) -> bool {
8442         unimplemented!()
8443     }
8444 }
8445 #[cfg(feature = "Win32_Foundation")]
8446 impl ::std::cmp::Eq for RPC_EE_INFO_PARAM_0 {}
8447 #[cfg(feature = "Win32_Foundation")]
8448 unsafe impl ::windows::runtime::Abi for RPC_EE_INFO_PARAM_0 {
8449     type Abi = Self;
8450     type DefaultType = Self;
8451 }
8452 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8453 #[repr(C)]
8454 pub struct RPC_ENDPOINT_TEMPLATEA {
8455     pub Version: u32,
8456     pub ProtSeq: *mut u8,
8457     pub Endpoint: *mut u8,
8458     pub SecurityDescriptor: *mut ::std::ffi::c_void,
8459     pub Backlog: u32,
8460 }
8461 impl RPC_ENDPOINT_TEMPLATEA {}
8462 impl ::std::default::Default for RPC_ENDPOINT_TEMPLATEA {
default() -> Self8463     fn default() -> Self {
8464         unsafe { ::std::mem::zeroed() }
8465     }
8466 }
8467 impl ::std::fmt::Debug for RPC_ENDPOINT_TEMPLATEA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8468     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8469         fmt.debug_struct("RPC_ENDPOINT_TEMPLATEA").field("Version", &self.Version).field("ProtSeq", &self.ProtSeq).field("Endpoint", &self.Endpoint).field("SecurityDescriptor", &self.SecurityDescriptor).field("Backlog", &self.Backlog).finish()
8470     }
8471 }
8472 impl ::std::cmp::PartialEq for RPC_ENDPOINT_TEMPLATEA {
eq(&self, other: &Self) -> bool8473     fn eq(&self, other: &Self) -> bool {
8474         self.Version == other.Version && self.ProtSeq == other.ProtSeq && self.Endpoint == other.Endpoint && self.SecurityDescriptor == other.SecurityDescriptor && self.Backlog == other.Backlog
8475     }
8476 }
8477 impl ::std::cmp::Eq for RPC_ENDPOINT_TEMPLATEA {}
8478 unsafe impl ::windows::runtime::Abi for RPC_ENDPOINT_TEMPLATEA {
8479     type Abi = Self;
8480     type DefaultType = Self;
8481 }
8482 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8483 #[repr(C)]
8484 pub struct RPC_ENDPOINT_TEMPLATEW {
8485     pub Version: u32,
8486     pub ProtSeq: *mut u16,
8487     pub Endpoint: *mut u16,
8488     pub SecurityDescriptor: *mut ::std::ffi::c_void,
8489     pub Backlog: u32,
8490 }
8491 impl RPC_ENDPOINT_TEMPLATEW {}
8492 impl ::std::default::Default for RPC_ENDPOINT_TEMPLATEW {
default() -> Self8493     fn default() -> Self {
8494         unsafe { ::std::mem::zeroed() }
8495     }
8496 }
8497 impl ::std::fmt::Debug for RPC_ENDPOINT_TEMPLATEW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8498     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8499         fmt.debug_struct("RPC_ENDPOINT_TEMPLATEW").field("Version", &self.Version).field("ProtSeq", &self.ProtSeq).field("Endpoint", &self.Endpoint).field("SecurityDescriptor", &self.SecurityDescriptor).field("Backlog", &self.Backlog).finish()
8500     }
8501 }
8502 impl ::std::cmp::PartialEq for RPC_ENDPOINT_TEMPLATEW {
eq(&self, other: &Self) -> bool8503     fn eq(&self, other: &Self) -> bool {
8504         self.Version == other.Version && self.ProtSeq == other.ProtSeq && self.Endpoint == other.Endpoint && self.SecurityDescriptor == other.SecurityDescriptor && self.Backlog == other.Backlog
8505     }
8506 }
8507 impl ::std::cmp::Eq for RPC_ENDPOINT_TEMPLATEW {}
8508 unsafe impl ::windows::runtime::Abi for RPC_ENDPOINT_TEMPLATEW {
8509     type Abi = Self;
8510     type DefaultType = Self;
8511 }
8512 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8513 #[repr(C)]
8514 pub struct RPC_ERROR_ENUM_HANDLE {
8515     pub Signature: u32,
8516     pub CurrentPos: *mut ::std::ffi::c_void,
8517     pub Head: *mut ::std::ffi::c_void,
8518 }
8519 impl RPC_ERROR_ENUM_HANDLE {}
8520 impl ::std::default::Default for RPC_ERROR_ENUM_HANDLE {
default() -> Self8521     fn default() -> Self {
8522         unsafe { ::std::mem::zeroed() }
8523     }
8524 }
8525 impl ::std::fmt::Debug for RPC_ERROR_ENUM_HANDLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8526     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8527         fmt.debug_struct("RPC_ERROR_ENUM_HANDLE").field("Signature", &self.Signature).field("CurrentPos", &self.CurrentPos).field("Head", &self.Head).finish()
8528     }
8529 }
8530 impl ::std::cmp::PartialEq for RPC_ERROR_ENUM_HANDLE {
eq(&self, other: &Self) -> bool8531     fn eq(&self, other: &Self) -> bool {
8532         self.Signature == other.Signature && self.CurrentPos == other.CurrentPos && self.Head == other.Head
8533     }
8534 }
8535 impl ::std::cmp::Eq for RPC_ERROR_ENUM_HANDLE {}
8536 unsafe impl ::windows::runtime::Abi for RPC_ERROR_ENUM_HANDLE {
8537     type Abi = Self;
8538     type DefaultType = Self;
8539 }
8540 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8541 #[repr(C)]
8542 #[cfg(feature = "Win32_Foundation")]
8543 pub struct RPC_EXTENDED_ERROR_INFO {
8544     pub Version: u32,
8545     pub ComputerName: super::super::Foundation::PWSTR,
8546     pub ProcessID: u32,
8547     pub u: RPC_EXTENDED_ERROR_INFO_0,
8548     pub GeneratingComponent: u32,
8549     pub Status: u32,
8550     pub DetectionLocation: u16,
8551     pub Flags: u16,
8552     pub NumberOfParameters: i32,
8553     pub Parameters: [RPC_EE_INFO_PARAM; 4],
8554 }
8555 #[cfg(feature = "Win32_Foundation")]
8556 impl RPC_EXTENDED_ERROR_INFO {}
8557 #[cfg(feature = "Win32_Foundation")]
8558 impl ::std::default::Default for RPC_EXTENDED_ERROR_INFO {
default() -> Self8559     fn default() -> Self {
8560         unsafe { ::std::mem::zeroed() }
8561     }
8562 }
8563 #[cfg(feature = "Win32_Foundation")]
8564 impl ::std::cmp::PartialEq for RPC_EXTENDED_ERROR_INFO {
eq(&self, _other: &Self) -> bool8565     fn eq(&self, _other: &Self) -> bool {
8566         unimplemented!()
8567     }
8568 }
8569 #[cfg(feature = "Win32_Foundation")]
8570 impl ::std::cmp::Eq for RPC_EXTENDED_ERROR_INFO {}
8571 #[cfg(feature = "Win32_Foundation")]
8572 unsafe impl ::windows::runtime::Abi for RPC_EXTENDED_ERROR_INFO {
8573     type Abi = Self;
8574     type DefaultType = Self;
8575 }
8576 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8577 #[repr(C)]
8578 #[cfg(feature = "Win32_Foundation")]
8579 pub union RPC_EXTENDED_ERROR_INFO_0 {
8580     pub SystemTime: super::super::Foundation::SYSTEMTIME,
8581     pub FileTime: super::super::Foundation::FILETIME,
8582 }
8583 #[cfg(feature = "Win32_Foundation")]
8584 impl RPC_EXTENDED_ERROR_INFO_0 {}
8585 #[cfg(feature = "Win32_Foundation")]
8586 impl ::std::default::Default for RPC_EXTENDED_ERROR_INFO_0 {
default() -> Self8587     fn default() -> Self {
8588         unsafe { ::std::mem::zeroed() }
8589     }
8590 }
8591 #[cfg(feature = "Win32_Foundation")]
8592 impl ::std::cmp::PartialEq for RPC_EXTENDED_ERROR_INFO_0 {
eq(&self, _other: &Self) -> bool8593     fn eq(&self, _other: &Self) -> bool {
8594         unimplemented!()
8595     }
8596 }
8597 #[cfg(feature = "Win32_Foundation")]
8598 impl ::std::cmp::Eq for RPC_EXTENDED_ERROR_INFO_0 {}
8599 #[cfg(feature = "Win32_Foundation")]
8600 unsafe impl ::windows::runtime::Abi for RPC_EXTENDED_ERROR_INFO_0 {
8601     type Abi = Self;
8602     type DefaultType = Self;
8603 }
8604 pub const RPC_FLAGS_VALID_BIT: u32 = 32768u32;
8605 pub type RPC_FORWARD_FUNCTION = unsafe extern "system" fn(interfaceid: *mut ::windows::runtime::GUID, interfaceversion: *mut RPC_VERSION, objectid: *mut ::windows::runtime::GUID, rpcpro: *mut u8, ppdestendpoint: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
8606 pub const RPC_FW_IF_FLAG_DCOM: u32 = 1u32;
8607 pub type RPC_HTTP_PROXY_FREE_STRING = unsafe extern "system" fn(string: *const u16);
8608 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8609 #[repr(transparent)]
8610 pub struct RPC_HTTP_REDIRECTOR_STAGE(pub i32);
8611 pub const RPCHTTP_RS_REDIRECT: RPC_HTTP_REDIRECTOR_STAGE = RPC_HTTP_REDIRECTOR_STAGE(1i32);
8612 pub const RPCHTTP_RS_ACCESS_1: RPC_HTTP_REDIRECTOR_STAGE = RPC_HTTP_REDIRECTOR_STAGE(2i32);
8613 pub const RPCHTTP_RS_SESSION: RPC_HTTP_REDIRECTOR_STAGE = RPC_HTTP_REDIRECTOR_STAGE(3i32);
8614 pub const RPCHTTP_RS_ACCESS_2: RPC_HTTP_REDIRECTOR_STAGE = RPC_HTTP_REDIRECTOR_STAGE(4i32);
8615 pub const RPCHTTP_RS_INTERFACE: RPC_HTTP_REDIRECTOR_STAGE = RPC_HTTP_REDIRECTOR_STAGE(5i32);
8616 impl ::std::convert::From<i32> for RPC_HTTP_REDIRECTOR_STAGE {
from(value: i32) -> Self8617     fn from(value: i32) -> Self {
8618         Self(value)
8619     }
8620 }
8621 unsafe impl ::windows::runtime::Abi for RPC_HTTP_REDIRECTOR_STAGE {
8622     type Abi = Self;
8623     type DefaultType = Self;
8624 }
8625 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8626 #[repr(C)]
8627 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_A {
8628     pub TransportCredentials: *mut SEC_WINNT_AUTH_IDENTITY_A,
8629     pub Flags: RPC_C_HTTP_FLAGS,
8630     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8631     pub NumberOfAuthnSchemes: u32,
8632     pub AuthnSchemes: *mut u32,
8633     pub ServerCertificateSubject: *mut u8,
8634 }
8635 impl RPC_HTTP_TRANSPORT_CREDENTIALS_A {}
8636 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_A {
default() -> Self8637     fn default() -> Self {
8638         unsafe { ::std::mem::zeroed() }
8639     }
8640 }
8641 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8642     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8643         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_A")
8644             .field("TransportCredentials", &self.TransportCredentials)
8645             .field("Flags", &self.Flags)
8646             .field("AuthenticationTarget", &self.AuthenticationTarget)
8647             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8648             .field("AuthnSchemes", &self.AuthnSchemes)
8649             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8650             .finish()
8651     }
8652 }
8653 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_A {
eq(&self, other: &Self) -> bool8654     fn eq(&self, other: &Self) -> bool {
8655         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject
8656     }
8657 }
8658 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_A {}
8659 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_A {
8660     type Abi = Self;
8661     type DefaultType = Self;
8662 }
8663 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8664 #[repr(C)]
8665 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {
8666     pub TransportCredentials: *mut SEC_WINNT_AUTH_IDENTITY_A,
8667     pub Flags: RPC_C_HTTP_FLAGS,
8668     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8669     pub NumberOfAuthnSchemes: u32,
8670     pub AuthnSchemes: *mut u32,
8671     pub ServerCertificateSubject: *mut u8,
8672     pub ProxyCredentials: *mut SEC_WINNT_AUTH_IDENTITY_A,
8673     pub NumberOfProxyAuthnSchemes: u32,
8674     pub ProxyAuthnSchemes: *mut u32,
8675 }
8676 impl RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {}
8677 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {
default() -> Self8678     fn default() -> Self {
8679         unsafe { ::std::mem::zeroed() }
8680     }
8681 }
8682 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8683     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8684         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A")
8685             .field("TransportCredentials", &self.TransportCredentials)
8686             .field("Flags", &self.Flags)
8687             .field("AuthenticationTarget", &self.AuthenticationTarget)
8688             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8689             .field("AuthnSchemes", &self.AuthnSchemes)
8690             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8691             .field("ProxyCredentials", &self.ProxyCredentials)
8692             .field("NumberOfProxyAuthnSchemes", &self.NumberOfProxyAuthnSchemes)
8693             .field("ProxyAuthnSchemes", &self.ProxyAuthnSchemes)
8694             .finish()
8695     }
8696 }
8697 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {
eq(&self, other: &Self) -> bool8698     fn eq(&self, other: &Self) -> bool {
8699         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject && self.ProxyCredentials == other.ProxyCredentials && self.NumberOfProxyAuthnSchemes == other.NumberOfProxyAuthnSchemes && self.ProxyAuthnSchemes == other.ProxyAuthnSchemes
8700     }
8701 }
8702 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {}
8703 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A {
8704     type Abi = Self;
8705     type DefaultType = Self;
8706 }
8707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8708 #[repr(C)]
8709 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {
8710     pub TransportCredentials: *mut SEC_WINNT_AUTH_IDENTITY_W,
8711     pub Flags: RPC_C_HTTP_FLAGS,
8712     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8713     pub NumberOfAuthnSchemes: u32,
8714     pub AuthnSchemes: *mut u32,
8715     pub ServerCertificateSubject: *mut u16,
8716     pub ProxyCredentials: *mut SEC_WINNT_AUTH_IDENTITY_W,
8717     pub NumberOfProxyAuthnSchemes: u32,
8718     pub ProxyAuthnSchemes: *mut u32,
8719 }
8720 impl RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {}
8721 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {
default() -> Self8722     fn default() -> Self {
8723         unsafe { ::std::mem::zeroed() }
8724     }
8725 }
8726 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8727     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8728         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W")
8729             .field("TransportCredentials", &self.TransportCredentials)
8730             .field("Flags", &self.Flags)
8731             .field("AuthenticationTarget", &self.AuthenticationTarget)
8732             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8733             .field("AuthnSchemes", &self.AuthnSchemes)
8734             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8735             .field("ProxyCredentials", &self.ProxyCredentials)
8736             .field("NumberOfProxyAuthnSchemes", &self.NumberOfProxyAuthnSchemes)
8737             .field("ProxyAuthnSchemes", &self.ProxyAuthnSchemes)
8738             .finish()
8739     }
8740 }
8741 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {
eq(&self, other: &Self) -> bool8742     fn eq(&self, other: &Self) -> bool {
8743         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject && self.ProxyCredentials == other.ProxyCredentials && self.NumberOfProxyAuthnSchemes == other.NumberOfProxyAuthnSchemes && self.ProxyAuthnSchemes == other.ProxyAuthnSchemes
8744     }
8745 }
8746 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {}
8747 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W {
8748     type Abi = Self;
8749     type DefaultType = Self;
8750 }
8751 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8752 #[repr(C)]
8753 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {
8754     pub TransportCredentials: *mut ::std::ffi::c_void,
8755     pub Flags: RPC_C_HTTP_FLAGS,
8756     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8757     pub NumberOfAuthnSchemes: u32,
8758     pub AuthnSchemes: *mut u32,
8759     pub ServerCertificateSubject: *mut u8,
8760     pub ProxyCredentials: *mut ::std::ffi::c_void,
8761     pub NumberOfProxyAuthnSchemes: u32,
8762     pub ProxyAuthnSchemes: *mut u32,
8763 }
8764 impl RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {}
8765 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {
default() -> Self8766     fn default() -> Self {
8767         unsafe { ::std::mem::zeroed() }
8768     }
8769 }
8770 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8771     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8772         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A")
8773             .field("TransportCredentials", &self.TransportCredentials)
8774             .field("Flags", &self.Flags)
8775             .field("AuthenticationTarget", &self.AuthenticationTarget)
8776             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8777             .field("AuthnSchemes", &self.AuthnSchemes)
8778             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8779             .field("ProxyCredentials", &self.ProxyCredentials)
8780             .field("NumberOfProxyAuthnSchemes", &self.NumberOfProxyAuthnSchemes)
8781             .field("ProxyAuthnSchemes", &self.ProxyAuthnSchemes)
8782             .finish()
8783     }
8784 }
8785 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {
eq(&self, other: &Self) -> bool8786     fn eq(&self, other: &Self) -> bool {
8787         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject && self.ProxyCredentials == other.ProxyCredentials && self.NumberOfProxyAuthnSchemes == other.NumberOfProxyAuthnSchemes && self.ProxyAuthnSchemes == other.ProxyAuthnSchemes
8788     }
8789 }
8790 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {}
8791 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A {
8792     type Abi = Self;
8793     type DefaultType = Self;
8794 }
8795 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8796 #[repr(C)]
8797 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {
8798     pub TransportCredentials: *mut ::std::ffi::c_void,
8799     pub Flags: RPC_C_HTTP_FLAGS,
8800     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8801     pub NumberOfAuthnSchemes: u32,
8802     pub AuthnSchemes: *mut u32,
8803     pub ServerCertificateSubject: *mut u16,
8804     pub ProxyCredentials: *mut ::std::ffi::c_void,
8805     pub NumberOfProxyAuthnSchemes: u32,
8806     pub ProxyAuthnSchemes: *mut u32,
8807 }
8808 impl RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {}
8809 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {
default() -> Self8810     fn default() -> Self {
8811         unsafe { ::std::mem::zeroed() }
8812     }
8813 }
8814 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8815     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8816         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W")
8817             .field("TransportCredentials", &self.TransportCredentials)
8818             .field("Flags", &self.Flags)
8819             .field("AuthenticationTarget", &self.AuthenticationTarget)
8820             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8821             .field("AuthnSchemes", &self.AuthnSchemes)
8822             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8823             .field("ProxyCredentials", &self.ProxyCredentials)
8824             .field("NumberOfProxyAuthnSchemes", &self.NumberOfProxyAuthnSchemes)
8825             .field("ProxyAuthnSchemes", &self.ProxyAuthnSchemes)
8826             .finish()
8827     }
8828 }
8829 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {
eq(&self, other: &Self) -> bool8830     fn eq(&self, other: &Self) -> bool {
8831         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject && self.ProxyCredentials == other.ProxyCredentials && self.NumberOfProxyAuthnSchemes == other.NumberOfProxyAuthnSchemes && self.ProxyAuthnSchemes == other.ProxyAuthnSchemes
8832     }
8833 }
8834 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {}
8835 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W {
8836     type Abi = Self;
8837     type DefaultType = Self;
8838 }
8839 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8840 #[repr(C)]
8841 pub struct RPC_HTTP_TRANSPORT_CREDENTIALS_W {
8842     pub TransportCredentials: *mut SEC_WINNT_AUTH_IDENTITY_W,
8843     pub Flags: RPC_C_HTTP_FLAGS,
8844     pub AuthenticationTarget: RPC_C_HTTP_AUTHN_TARGET,
8845     pub NumberOfAuthnSchemes: u32,
8846     pub AuthnSchemes: *mut u32,
8847     pub ServerCertificateSubject: *mut u16,
8848 }
8849 impl RPC_HTTP_TRANSPORT_CREDENTIALS_W {}
8850 impl ::std::default::Default for RPC_HTTP_TRANSPORT_CREDENTIALS_W {
default() -> Self8851     fn default() -> Self {
8852         unsafe { ::std::mem::zeroed() }
8853     }
8854 }
8855 impl ::std::fmt::Debug for RPC_HTTP_TRANSPORT_CREDENTIALS_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8856     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8857         fmt.debug_struct("RPC_HTTP_TRANSPORT_CREDENTIALS_W")
8858             .field("TransportCredentials", &self.TransportCredentials)
8859             .field("Flags", &self.Flags)
8860             .field("AuthenticationTarget", &self.AuthenticationTarget)
8861             .field("NumberOfAuthnSchemes", &self.NumberOfAuthnSchemes)
8862             .field("AuthnSchemes", &self.AuthnSchemes)
8863             .field("ServerCertificateSubject", &self.ServerCertificateSubject)
8864             .finish()
8865     }
8866 }
8867 impl ::std::cmp::PartialEq for RPC_HTTP_TRANSPORT_CREDENTIALS_W {
eq(&self, other: &Self) -> bool8868     fn eq(&self, other: &Self) -> bool {
8869         self.TransportCredentials == other.TransportCredentials && self.Flags == other.Flags && self.AuthenticationTarget == other.AuthenticationTarget && self.NumberOfAuthnSchemes == other.NumberOfAuthnSchemes && self.AuthnSchemes == other.AuthnSchemes && self.ServerCertificateSubject == other.ServerCertificateSubject
8870     }
8871 }
8872 impl ::std::cmp::Eq for RPC_HTTP_TRANSPORT_CREDENTIALS_W {}
8873 unsafe impl ::windows::runtime::Abi for RPC_HTTP_TRANSPORT_CREDENTIALS_W {
8874     type Abi = Self;
8875     type DefaultType = Self;
8876 }
8877 pub const RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH: u32 = 16u32;
8878 pub const RPC_IF_ALLOW_LOCAL_ONLY: u32 = 32u32;
8879 pub const RPC_IF_ALLOW_SECURE_ONLY: u32 = 8u32;
8880 pub const RPC_IF_ALLOW_UNKNOWN_AUTHORITY: u32 = 4u32;
8881 pub const RPC_IF_ASYNC_CALLBACK: u32 = 256u32;
8882 pub const RPC_IF_AUTOLISTEN: u32 = 1u32;
8883 pub type RPC_IF_CALLBACK_FN = unsafe extern "system" fn(interfaceuuid: *const ::std::ffi::c_void, context: *const ::std::ffi::c_void) -> RPC_STATUS;
8884 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8885 #[repr(C)]
8886 pub struct RPC_IF_ID {
8887     pub Uuid: ::windows::runtime::GUID,
8888     pub VersMajor: u16,
8889     pub VersMinor: u16,
8890 }
8891 impl RPC_IF_ID {}
8892 impl ::std::default::Default for RPC_IF_ID {
default() -> Self8893     fn default() -> Self {
8894         unsafe { ::std::mem::zeroed() }
8895     }
8896 }
8897 impl ::std::fmt::Debug for RPC_IF_ID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8898     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8899         fmt.debug_struct("RPC_IF_ID").field("Uuid", &self.Uuid).field("VersMajor", &self.VersMajor).field("VersMinor", &self.VersMinor).finish()
8900     }
8901 }
8902 impl ::std::cmp::PartialEq for RPC_IF_ID {
eq(&self, other: &Self) -> bool8903     fn eq(&self, other: &Self) -> bool {
8904         self.Uuid == other.Uuid && self.VersMajor == other.VersMajor && self.VersMinor == other.VersMinor
8905     }
8906 }
8907 impl ::std::cmp::Eq for RPC_IF_ID {}
8908 unsafe impl ::windows::runtime::Abi for RPC_IF_ID {
8909     type Abi = Self;
8910     type DefaultType = Self;
8911 }
8912 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8913 #[repr(C)]
8914 pub struct RPC_IF_ID_VECTOR {
8915     pub Count: u32,
8916     pub IfId: [*mut RPC_IF_ID; 1],
8917 }
8918 impl RPC_IF_ID_VECTOR {}
8919 impl ::std::default::Default for RPC_IF_ID_VECTOR {
default() -> Self8920     fn default() -> Self {
8921         unsafe { ::std::mem::zeroed() }
8922     }
8923 }
8924 impl ::std::fmt::Debug for RPC_IF_ID_VECTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8925     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8926         fmt.debug_struct("RPC_IF_ID_VECTOR").field("Count", &self.Count).field("IfId", &self.IfId).finish()
8927     }
8928 }
8929 impl ::std::cmp::PartialEq for RPC_IF_ID_VECTOR {
eq(&self, other: &Self) -> bool8930     fn eq(&self, other: &Self) -> bool {
8931         self.Count == other.Count && self.IfId == other.IfId
8932     }
8933 }
8934 impl ::std::cmp::Eq for RPC_IF_ID_VECTOR {}
8935 unsafe impl ::windows::runtime::Abi for RPC_IF_ID_VECTOR {
8936     type Abi = Self;
8937     type DefaultType = Self;
8938 }
8939 pub const RPC_IF_OLE: u32 = 2u32;
8940 pub const RPC_IF_SEC_CACHE_PER_PROC: u32 = 128u32;
8941 pub const RPC_IF_SEC_NO_CACHE: u32 = 64u32;
8942 pub type RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN = unsafe extern "system" fn(ifgroup: *const ::std::ffi::c_void, idlecallbackcontext: *const ::std::ffi::c_void, isgroupidle: u32);
8943 pub const RPC_INTERFACE_HAS_PIPES: u32 = 1u32;
8944 #[derive(:: std :: clone :: Clone)]
8945 #[repr(C)]
8946 pub struct RPC_INTERFACE_TEMPLATEA {
8947     pub Version: u32,
8948     pub IfSpec: *mut ::std::ffi::c_void,
8949     pub MgrTypeUuid: *mut ::windows::runtime::GUID,
8950     pub MgrEpv: *mut ::std::ffi::c_void,
8951     pub Flags: u32,
8952     pub MaxCalls: u32,
8953     pub MaxRpcSize: u32,
8954     pub IfCallback: ::std::option::Option<RPC_IF_CALLBACK_FN>,
8955     pub UuidVector: *mut UUID_VECTOR,
8956     pub Annotation: *mut u8,
8957     pub SecurityDescriptor: *mut ::std::ffi::c_void,
8958 }
8959 impl RPC_INTERFACE_TEMPLATEA {}
8960 impl ::std::default::Default for RPC_INTERFACE_TEMPLATEA {
default() -> Self8961     fn default() -> Self {
8962         unsafe { ::std::mem::zeroed() }
8963     }
8964 }
8965 impl ::std::fmt::Debug for RPC_INTERFACE_TEMPLATEA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8966     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8967         fmt.debug_struct("RPC_INTERFACE_TEMPLATEA")
8968             .field("Version", &self.Version)
8969             .field("IfSpec", &self.IfSpec)
8970             .field("MgrTypeUuid", &self.MgrTypeUuid)
8971             .field("MgrEpv", &self.MgrEpv)
8972             .field("Flags", &self.Flags)
8973             .field("MaxCalls", &self.MaxCalls)
8974             .field("MaxRpcSize", &self.MaxRpcSize)
8975             .field("UuidVector", &self.UuidVector)
8976             .field("Annotation", &self.Annotation)
8977             .field("SecurityDescriptor", &self.SecurityDescriptor)
8978             .finish()
8979     }
8980 }
8981 impl ::std::cmp::PartialEq for RPC_INTERFACE_TEMPLATEA {
eq(&self, other: &Self) -> bool8982     fn eq(&self, other: &Self) -> bool {
8983         self.Version == other.Version && self.IfSpec == other.IfSpec && self.MgrTypeUuid == other.MgrTypeUuid && self.MgrEpv == other.MgrEpv && self.Flags == other.Flags && self.MaxCalls == other.MaxCalls && self.MaxRpcSize == other.MaxRpcSize && self.IfCallback.map(|f| f as usize) == other.IfCallback.map(|f| f as usize) && self.UuidVector == other.UuidVector && self.Annotation == other.Annotation && self.SecurityDescriptor == other.SecurityDescriptor
8984     }
8985 }
8986 impl ::std::cmp::Eq for RPC_INTERFACE_TEMPLATEA {}
8987 unsafe impl ::windows::runtime::Abi for RPC_INTERFACE_TEMPLATEA {
8988     type Abi = ::std::mem::ManuallyDrop<Self>;
8989     type DefaultType = Self;
8990 }
8991 #[derive(:: std :: clone :: Clone)]
8992 #[repr(C)]
8993 pub struct RPC_INTERFACE_TEMPLATEW {
8994     pub Version: u32,
8995     pub IfSpec: *mut ::std::ffi::c_void,
8996     pub MgrTypeUuid: *mut ::windows::runtime::GUID,
8997     pub MgrEpv: *mut ::std::ffi::c_void,
8998     pub Flags: u32,
8999     pub MaxCalls: u32,
9000     pub MaxRpcSize: u32,
9001     pub IfCallback: ::std::option::Option<RPC_IF_CALLBACK_FN>,
9002     pub UuidVector: *mut UUID_VECTOR,
9003     pub Annotation: *mut u16,
9004     pub SecurityDescriptor: *mut ::std::ffi::c_void,
9005 }
9006 impl RPC_INTERFACE_TEMPLATEW {}
9007 impl ::std::default::Default for RPC_INTERFACE_TEMPLATEW {
default() -> Self9008     fn default() -> Self {
9009         unsafe { ::std::mem::zeroed() }
9010     }
9011 }
9012 impl ::std::fmt::Debug for RPC_INTERFACE_TEMPLATEW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9013     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9014         fmt.debug_struct("RPC_INTERFACE_TEMPLATEW")
9015             .field("Version", &self.Version)
9016             .field("IfSpec", &self.IfSpec)
9017             .field("MgrTypeUuid", &self.MgrTypeUuid)
9018             .field("MgrEpv", &self.MgrEpv)
9019             .field("Flags", &self.Flags)
9020             .field("MaxCalls", &self.MaxCalls)
9021             .field("MaxRpcSize", &self.MaxRpcSize)
9022             .field("UuidVector", &self.UuidVector)
9023             .field("Annotation", &self.Annotation)
9024             .field("SecurityDescriptor", &self.SecurityDescriptor)
9025             .finish()
9026     }
9027 }
9028 impl ::std::cmp::PartialEq for RPC_INTERFACE_TEMPLATEW {
eq(&self, other: &Self) -> bool9029     fn eq(&self, other: &Self) -> bool {
9030         self.Version == other.Version && self.IfSpec == other.IfSpec && self.MgrTypeUuid == other.MgrTypeUuid && self.MgrEpv == other.MgrEpv && self.Flags == other.Flags && self.MaxCalls == other.MaxCalls && self.MaxRpcSize == other.MaxRpcSize && self.IfCallback.map(|f| f as usize) == other.IfCallback.map(|f| f as usize) && self.UuidVector == other.UuidVector && self.Annotation == other.Annotation && self.SecurityDescriptor == other.SecurityDescriptor
9031     }
9032 }
9033 impl ::std::cmp::Eq for RPC_INTERFACE_TEMPLATEW {}
9034 unsafe impl ::windows::runtime::Abi for RPC_INTERFACE_TEMPLATEW {
9035     type Abi = ::std::mem::ManuallyDrop<Self>;
9036     type DefaultType = Self;
9037 }
9038 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9039 #[repr(C)]
9040 pub struct RPC_MESSAGE {
9041     pub Handle: *mut ::std::ffi::c_void,
9042     pub DataRepresentation: u32,
9043     pub Buffer: *mut ::std::ffi::c_void,
9044     pub BufferLength: u32,
9045     pub ProcNum: u32,
9046     pub TransferSyntax: *mut RPC_SYNTAX_IDENTIFIER,
9047     pub RpcInterfaceInformation: *mut ::std::ffi::c_void,
9048     pub ReservedForRuntime: *mut ::std::ffi::c_void,
9049     pub ManagerEpv: *mut ::std::ffi::c_void,
9050     pub ImportContext: *mut ::std::ffi::c_void,
9051     pub RpcFlags: u32,
9052 }
9053 impl RPC_MESSAGE {}
9054 impl ::std::default::Default for RPC_MESSAGE {
default() -> Self9055     fn default() -> Self {
9056         unsafe { ::std::mem::zeroed() }
9057     }
9058 }
9059 impl ::std::fmt::Debug for RPC_MESSAGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9060     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9061         fmt.debug_struct("RPC_MESSAGE")
9062             .field("Handle", &self.Handle)
9063             .field("DataRepresentation", &self.DataRepresentation)
9064             .field("Buffer", &self.Buffer)
9065             .field("BufferLength", &self.BufferLength)
9066             .field("ProcNum", &self.ProcNum)
9067             .field("TransferSyntax", &self.TransferSyntax)
9068             .field("RpcInterfaceInformation", &self.RpcInterfaceInformation)
9069             .field("ReservedForRuntime", &self.ReservedForRuntime)
9070             .field("ManagerEpv", &self.ManagerEpv)
9071             .field("ImportContext", &self.ImportContext)
9072             .field("RpcFlags", &self.RpcFlags)
9073             .finish()
9074     }
9075 }
9076 impl ::std::cmp::PartialEq for RPC_MESSAGE {
eq(&self, other: &Self) -> bool9077     fn eq(&self, other: &Self) -> bool {
9078         self.Handle == other.Handle && self.DataRepresentation == other.DataRepresentation && self.Buffer == other.Buffer && self.BufferLength == other.BufferLength && self.ProcNum == other.ProcNum && self.TransferSyntax == other.TransferSyntax && self.RpcInterfaceInformation == other.RpcInterfaceInformation && self.ReservedForRuntime == other.ReservedForRuntime && self.ManagerEpv == other.ManagerEpv && self.ImportContext == other.ImportContext && self.RpcFlags == other.RpcFlags
9079     }
9080 }
9081 impl ::std::cmp::Eq for RPC_MESSAGE {}
9082 unsafe impl ::windows::runtime::Abi for RPC_MESSAGE {
9083     type Abi = Self;
9084     type DefaultType = Self;
9085 }
9086 pub type RPC_MGMT_AUTHORIZATION_FN = unsafe extern "system" fn(clientbinding: *const ::std::ffi::c_void, requestedmgmtoperation: u32, status: *mut RPC_STATUS) -> i32;
9087 pub const RPC_NCA_FLAGS_BROADCAST: u32 = 2u32;
9088 pub const RPC_NCA_FLAGS_DEFAULT: u32 = 0u32;
9089 pub const RPC_NCA_FLAGS_IDEMPOTENT: u32 = 1u32;
9090 pub const RPC_NCA_FLAGS_MAYBE: u32 = 4u32;
9091 pub type RPC_NEW_HTTP_PROXY_CHANNEL = unsafe extern "system" fn(redirectorstage: RPC_HTTP_REDIRECTOR_STAGE, servername: *const u16, serverport: *const u16, remoteuser: *const u16, authtype: *const u16, resourceuuid: *mut ::std::ffi::c_void, sessionid: *mut ::std::ffi::c_void, interface: *const ::std::ffi::c_void, reserved: *const ::std::ffi::c_void, flags: u32, newservername: *mut *mut u16, newserverport: *mut *mut u16) -> RPC_STATUS;
9092 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9093 #[repr(transparent)]
9094 pub struct RPC_NOTIFICATIONS(pub i32);
9095 pub const RpcNotificationCallNone: RPC_NOTIFICATIONS = RPC_NOTIFICATIONS(0i32);
9096 pub const RpcNotificationClientDisconnect: RPC_NOTIFICATIONS = RPC_NOTIFICATIONS(1i32);
9097 pub const RpcNotificationCallCancel: RPC_NOTIFICATIONS = RPC_NOTIFICATIONS(2i32);
9098 impl ::std::convert::From<i32> for RPC_NOTIFICATIONS {
from(value: i32) -> Self9099     fn from(value: i32) -> Self {
9100         Self(value)
9101     }
9102 }
9103 unsafe impl ::windows::runtime::Abi for RPC_NOTIFICATIONS {
9104     type Abi = Self;
9105     type DefaultType = Self;
9106 }
9107 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9108 #[repr(transparent)]
9109 pub struct RPC_NOTIFICATION_TYPES(pub i32);
9110 pub const RpcNotificationTypeNone: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(0i32);
9111 pub const RpcNotificationTypeEvent: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(1i32);
9112 pub const RpcNotificationTypeApc: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(2i32);
9113 pub const RpcNotificationTypeIoc: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(3i32);
9114 pub const RpcNotificationTypeHwnd: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(4i32);
9115 pub const RpcNotificationTypeCallback: RPC_NOTIFICATION_TYPES = RPC_NOTIFICATION_TYPES(5i32);
9116 impl ::std::convert::From<i32> for RPC_NOTIFICATION_TYPES {
from(value: i32) -> Self9117     fn from(value: i32) -> Self {
9118         Self(value)
9119     }
9120 }
9121 unsafe impl ::windows::runtime::Abi for RPC_NOTIFICATION_TYPES {
9122     type Abi = Self;
9123     type DefaultType = Self;
9124 }
9125 pub type RPC_OBJECT_INQ_FN = unsafe extern "system" fn(objectuuid: *const ::windows::runtime::GUID, typeuuid: *mut ::windows::runtime::GUID, status: *mut RPC_STATUS);
9126 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9127 #[repr(C)]
9128 pub struct RPC_POLICY {
9129     pub Length: u32,
9130     pub EndpointFlags: u32,
9131     pub NICFlags: u32,
9132 }
9133 impl RPC_POLICY {}
9134 impl ::std::default::Default for RPC_POLICY {
default() -> Self9135     fn default() -> Self {
9136         unsafe { ::std::mem::zeroed() }
9137     }
9138 }
9139 impl ::std::fmt::Debug for RPC_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9140     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9141         fmt.debug_struct("RPC_POLICY").field("Length", &self.Length).field("EndpointFlags", &self.EndpointFlags).field("NICFlags", &self.NICFlags).finish()
9142     }
9143 }
9144 impl ::std::cmp::PartialEq for RPC_POLICY {
eq(&self, other: &Self) -> bool9145     fn eq(&self, other: &Self) -> bool {
9146         self.Length == other.Length && self.EndpointFlags == other.EndpointFlags && self.NICFlags == other.NICFlags
9147     }
9148 }
9149 impl ::std::cmp::Eq for RPC_POLICY {}
9150 unsafe impl ::windows::runtime::Abi for RPC_POLICY {
9151     type Abi = Self;
9152     type DefaultType = Self;
9153 }
9154 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9155 #[repr(C)]
9156 pub struct RPC_PROTSEQ_ENDPOINT {
9157     pub RpcProtocolSequence: *mut u8,
9158     pub Endpoint: *mut u8,
9159 }
9160 impl RPC_PROTSEQ_ENDPOINT {}
9161 impl ::std::default::Default for RPC_PROTSEQ_ENDPOINT {
default() -> Self9162     fn default() -> Self {
9163         unsafe { ::std::mem::zeroed() }
9164     }
9165 }
9166 impl ::std::fmt::Debug for RPC_PROTSEQ_ENDPOINT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9167     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9168         fmt.debug_struct("RPC_PROTSEQ_ENDPOINT").field("RpcProtocolSequence", &self.RpcProtocolSequence).field("Endpoint", &self.Endpoint).finish()
9169     }
9170 }
9171 impl ::std::cmp::PartialEq for RPC_PROTSEQ_ENDPOINT {
eq(&self, other: &Self) -> bool9172     fn eq(&self, other: &Self) -> bool {
9173         self.RpcProtocolSequence == other.RpcProtocolSequence && self.Endpoint == other.Endpoint
9174     }
9175 }
9176 impl ::std::cmp::Eq for RPC_PROTSEQ_ENDPOINT {}
9177 unsafe impl ::windows::runtime::Abi for RPC_PROTSEQ_ENDPOINT {
9178     type Abi = Self;
9179     type DefaultType = Self;
9180 }
9181 pub const RPC_PROTSEQ_HTTP: u32 = 4u32;
9182 pub const RPC_PROTSEQ_LRPC: u32 = 3u32;
9183 pub const RPC_PROTSEQ_NMP: u32 = 2u32;
9184 pub const RPC_PROTSEQ_TCP: u32 = 1u32;
9185 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9186 #[repr(C)]
9187 pub struct RPC_PROTSEQ_VECTORA {
9188     pub Count: u32,
9189     pub Protseq: [*mut u8; 1],
9190 }
9191 impl RPC_PROTSEQ_VECTORA {}
9192 impl ::std::default::Default for RPC_PROTSEQ_VECTORA {
default() -> Self9193     fn default() -> Self {
9194         unsafe { ::std::mem::zeroed() }
9195     }
9196 }
9197 impl ::std::fmt::Debug for RPC_PROTSEQ_VECTORA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9198     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9199         fmt.debug_struct("RPC_PROTSEQ_VECTORA").field("Count", &self.Count).field("Protseq", &self.Protseq).finish()
9200     }
9201 }
9202 impl ::std::cmp::PartialEq for RPC_PROTSEQ_VECTORA {
eq(&self, other: &Self) -> bool9203     fn eq(&self, other: &Self) -> bool {
9204         self.Count == other.Count && self.Protseq == other.Protseq
9205     }
9206 }
9207 impl ::std::cmp::Eq for RPC_PROTSEQ_VECTORA {}
9208 unsafe impl ::windows::runtime::Abi for RPC_PROTSEQ_VECTORA {
9209     type Abi = Self;
9210     type DefaultType = Self;
9211 }
9212 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9213 #[repr(C)]
9214 pub struct RPC_PROTSEQ_VECTORW {
9215     pub Count: u32,
9216     pub Protseq: [*mut u16; 1],
9217 }
9218 impl RPC_PROTSEQ_VECTORW {}
9219 impl ::std::default::Default for RPC_PROTSEQ_VECTORW {
default() -> Self9220     fn default() -> Self {
9221         unsafe { ::std::mem::zeroed() }
9222     }
9223 }
9224 impl ::std::fmt::Debug for RPC_PROTSEQ_VECTORW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9225     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9226         fmt.debug_struct("RPC_PROTSEQ_VECTORW").field("Count", &self.Count).field("Protseq", &self.Protseq).finish()
9227     }
9228 }
9229 impl ::std::cmp::PartialEq for RPC_PROTSEQ_VECTORW {
eq(&self, other: &Self) -> bool9230     fn eq(&self, other: &Self) -> bool {
9231         self.Count == other.Count && self.Protseq == other.Protseq
9232     }
9233 }
9234 impl ::std::cmp::Eq for RPC_PROTSEQ_VECTORW {}
9235 unsafe impl ::windows::runtime::Abi for RPC_PROTSEQ_VECTORW {
9236     type Abi = Self;
9237     type DefaultType = Self;
9238 }
9239 pub const RPC_PROXY_CONNECTION_TYPE_IN_PROXY: u32 = 0u32;
9240 pub const RPC_PROXY_CONNECTION_TYPE_OUT_PROXY: u32 = 1u32;
9241 pub const RPC_P_ADDR_FORMAT_TCP_IPV4: u32 = 1u32;
9242 pub const RPC_P_ADDR_FORMAT_TCP_IPV6: u32 = 2u32;
9243 pub const RPC_QUERY_CALL_LOCAL_ADDRESS: u32 = 8u32;
9244 pub const RPC_QUERY_CLIENT_ID: u32 = 128u32;
9245 pub const RPC_QUERY_CLIENT_PID: u32 = 16u32;
9246 pub const RPC_QUERY_CLIENT_PRINCIPAL_NAME: u32 = 4u32;
9247 pub const RPC_QUERY_IS_CLIENT_LOCAL: u32 = 32u32;
9248 pub const RPC_QUERY_NO_AUTH_REQUIRED: u32 = 64u32;
9249 pub const RPC_QUERY_SERVER_PRINCIPAL_NAME: u32 = 2u32;
9250 pub type RPC_SECURITY_CALLBACK_FN = unsafe extern "system" fn(context: *const ::std::ffi::c_void);
9251 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9252 #[repr(C)]
9253 #[cfg(feature = "Win32_System_Com")]
9254 pub struct RPC_SECURITY_QOS {
9255     pub Version: u32,
9256     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9257     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9258     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9259 }
9260 #[cfg(feature = "Win32_System_Com")]
9261 impl RPC_SECURITY_QOS {}
9262 #[cfg(feature = "Win32_System_Com")]
9263 impl ::std::default::Default for RPC_SECURITY_QOS {
default() -> Self9264     fn default() -> Self {
9265         unsafe { ::std::mem::zeroed() }
9266     }
9267 }
9268 #[cfg(feature = "Win32_System_Com")]
9269 impl ::std::fmt::Debug for RPC_SECURITY_QOS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9270     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9271         fmt.debug_struct("RPC_SECURITY_QOS").field("Version", &self.Version).field("Capabilities", &self.Capabilities).field("IdentityTracking", &self.IdentityTracking).field("ImpersonationType", &self.ImpersonationType).finish()
9272     }
9273 }
9274 #[cfg(feature = "Win32_System_Com")]
9275 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS {
eq(&self, other: &Self) -> bool9276     fn eq(&self, other: &Self) -> bool {
9277         self.Version == other.Version && self.Capabilities == other.Capabilities && self.IdentityTracking == other.IdentityTracking && self.ImpersonationType == other.ImpersonationType
9278     }
9279 }
9280 #[cfg(feature = "Win32_System_Com")]
9281 impl ::std::cmp::Eq for RPC_SECURITY_QOS {}
9282 #[cfg(feature = "Win32_System_Com")]
9283 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS {
9284     type Abi = Self;
9285     type DefaultType = Self;
9286 }
9287 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9288 #[repr(C)]
9289 #[cfg(feature = "Win32_System_Com")]
9290 pub struct RPC_SECURITY_QOS_V2_A {
9291     pub Version: u32,
9292     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9293     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9294     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9295     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9296     pub u: RPC_SECURITY_QOS_V2_A_0,
9297 }
9298 #[cfg(feature = "Win32_System_Com")]
9299 impl RPC_SECURITY_QOS_V2_A {}
9300 #[cfg(feature = "Win32_System_Com")]
9301 impl ::std::default::Default for RPC_SECURITY_QOS_V2_A {
default() -> Self9302     fn default() -> Self {
9303         unsafe { ::std::mem::zeroed() }
9304     }
9305 }
9306 #[cfg(feature = "Win32_System_Com")]
9307 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V2_A {
eq(&self, _other: &Self) -> bool9308     fn eq(&self, _other: &Self) -> bool {
9309         unimplemented!()
9310     }
9311 }
9312 #[cfg(feature = "Win32_System_Com")]
9313 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V2_A {}
9314 #[cfg(feature = "Win32_System_Com")]
9315 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V2_A {
9316     type Abi = Self;
9317     type DefaultType = Self;
9318 }
9319 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9320 #[repr(C)]
9321 pub union RPC_SECURITY_QOS_V2_A_0 {
9322     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_A,
9323 }
9324 impl RPC_SECURITY_QOS_V2_A_0 {}
9325 impl ::std::default::Default for RPC_SECURITY_QOS_V2_A_0 {
default() -> Self9326     fn default() -> Self {
9327         unsafe { ::std::mem::zeroed() }
9328     }
9329 }
9330 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V2_A_0 {
eq(&self, _other: &Self) -> bool9331     fn eq(&self, _other: &Self) -> bool {
9332         unimplemented!()
9333     }
9334 }
9335 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V2_A_0 {}
9336 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V2_A_0 {
9337     type Abi = Self;
9338     type DefaultType = Self;
9339 }
9340 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9341 #[repr(C)]
9342 #[cfg(feature = "Win32_System_Com")]
9343 pub struct RPC_SECURITY_QOS_V2_W {
9344     pub Version: u32,
9345     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9346     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9347     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9348     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9349     pub u: RPC_SECURITY_QOS_V2_W_0,
9350 }
9351 #[cfg(feature = "Win32_System_Com")]
9352 impl RPC_SECURITY_QOS_V2_W {}
9353 #[cfg(feature = "Win32_System_Com")]
9354 impl ::std::default::Default for RPC_SECURITY_QOS_V2_W {
default() -> Self9355     fn default() -> Self {
9356         unsafe { ::std::mem::zeroed() }
9357     }
9358 }
9359 #[cfg(feature = "Win32_System_Com")]
9360 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V2_W {
eq(&self, _other: &Self) -> bool9361     fn eq(&self, _other: &Self) -> bool {
9362         unimplemented!()
9363     }
9364 }
9365 #[cfg(feature = "Win32_System_Com")]
9366 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V2_W {}
9367 #[cfg(feature = "Win32_System_Com")]
9368 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V2_W {
9369     type Abi = Self;
9370     type DefaultType = Self;
9371 }
9372 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9373 #[repr(C)]
9374 pub union RPC_SECURITY_QOS_V2_W_0 {
9375     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_W,
9376 }
9377 impl RPC_SECURITY_QOS_V2_W_0 {}
9378 impl ::std::default::Default for RPC_SECURITY_QOS_V2_W_0 {
default() -> Self9379     fn default() -> Self {
9380         unsafe { ::std::mem::zeroed() }
9381     }
9382 }
9383 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V2_W_0 {
eq(&self, _other: &Self) -> bool9384     fn eq(&self, _other: &Self) -> bool {
9385         unimplemented!()
9386     }
9387 }
9388 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V2_W_0 {}
9389 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V2_W_0 {
9390     type Abi = Self;
9391     type DefaultType = Self;
9392 }
9393 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9394 #[repr(C)]
9395 #[cfg(feature = "Win32_System_Com")]
9396 pub struct RPC_SECURITY_QOS_V3_A {
9397     pub Version: u32,
9398     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9399     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9400     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9401     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9402     pub u: RPC_SECURITY_QOS_V3_A_0,
9403     pub Sid: *mut ::std::ffi::c_void,
9404 }
9405 #[cfg(feature = "Win32_System_Com")]
9406 impl RPC_SECURITY_QOS_V3_A {}
9407 #[cfg(feature = "Win32_System_Com")]
9408 impl ::std::default::Default for RPC_SECURITY_QOS_V3_A {
default() -> Self9409     fn default() -> Self {
9410         unsafe { ::std::mem::zeroed() }
9411     }
9412 }
9413 #[cfg(feature = "Win32_System_Com")]
9414 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V3_A {
eq(&self, _other: &Self) -> bool9415     fn eq(&self, _other: &Self) -> bool {
9416         unimplemented!()
9417     }
9418 }
9419 #[cfg(feature = "Win32_System_Com")]
9420 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V3_A {}
9421 #[cfg(feature = "Win32_System_Com")]
9422 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V3_A {
9423     type Abi = Self;
9424     type DefaultType = Self;
9425 }
9426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9427 #[repr(C)]
9428 pub union RPC_SECURITY_QOS_V3_A_0 {
9429     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_A,
9430 }
9431 impl RPC_SECURITY_QOS_V3_A_0 {}
9432 impl ::std::default::Default for RPC_SECURITY_QOS_V3_A_0 {
default() -> Self9433     fn default() -> Self {
9434         unsafe { ::std::mem::zeroed() }
9435     }
9436 }
9437 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V3_A_0 {
eq(&self, _other: &Self) -> bool9438     fn eq(&self, _other: &Self) -> bool {
9439         unimplemented!()
9440     }
9441 }
9442 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V3_A_0 {}
9443 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V3_A_0 {
9444     type Abi = Self;
9445     type DefaultType = Self;
9446 }
9447 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9448 #[repr(C)]
9449 #[cfg(feature = "Win32_System_Com")]
9450 pub struct RPC_SECURITY_QOS_V3_W {
9451     pub Version: u32,
9452     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9453     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9454     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9455     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9456     pub u: RPC_SECURITY_QOS_V3_W_0,
9457     pub Sid: *mut ::std::ffi::c_void,
9458 }
9459 #[cfg(feature = "Win32_System_Com")]
9460 impl RPC_SECURITY_QOS_V3_W {}
9461 #[cfg(feature = "Win32_System_Com")]
9462 impl ::std::default::Default for RPC_SECURITY_QOS_V3_W {
default() -> Self9463     fn default() -> Self {
9464         unsafe { ::std::mem::zeroed() }
9465     }
9466 }
9467 #[cfg(feature = "Win32_System_Com")]
9468 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V3_W {
eq(&self, _other: &Self) -> bool9469     fn eq(&self, _other: &Self) -> bool {
9470         unimplemented!()
9471     }
9472 }
9473 #[cfg(feature = "Win32_System_Com")]
9474 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V3_W {}
9475 #[cfg(feature = "Win32_System_Com")]
9476 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V3_W {
9477     type Abi = Self;
9478     type DefaultType = Self;
9479 }
9480 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9481 #[repr(C)]
9482 pub union RPC_SECURITY_QOS_V3_W_0 {
9483     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_W,
9484 }
9485 impl RPC_SECURITY_QOS_V3_W_0 {}
9486 impl ::std::default::Default for RPC_SECURITY_QOS_V3_W_0 {
default() -> Self9487     fn default() -> Self {
9488         unsafe { ::std::mem::zeroed() }
9489     }
9490 }
9491 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V3_W_0 {
eq(&self, _other: &Self) -> bool9492     fn eq(&self, _other: &Self) -> bool {
9493         unimplemented!()
9494     }
9495 }
9496 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V3_W_0 {}
9497 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V3_W_0 {
9498     type Abi = Self;
9499     type DefaultType = Self;
9500 }
9501 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9502 #[repr(C)]
9503 #[cfg(feature = "Win32_System_Com")]
9504 pub struct RPC_SECURITY_QOS_V4_A {
9505     pub Version: u32,
9506     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9507     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9508     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9509     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9510     pub u: RPC_SECURITY_QOS_V4_A_0,
9511     pub Sid: *mut ::std::ffi::c_void,
9512     pub EffectiveOnly: u32,
9513 }
9514 #[cfg(feature = "Win32_System_Com")]
9515 impl RPC_SECURITY_QOS_V4_A {}
9516 #[cfg(feature = "Win32_System_Com")]
9517 impl ::std::default::Default for RPC_SECURITY_QOS_V4_A {
default() -> Self9518     fn default() -> Self {
9519         unsafe { ::std::mem::zeroed() }
9520     }
9521 }
9522 #[cfg(feature = "Win32_System_Com")]
9523 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V4_A {
eq(&self, _other: &Self) -> bool9524     fn eq(&self, _other: &Self) -> bool {
9525         unimplemented!()
9526     }
9527 }
9528 #[cfg(feature = "Win32_System_Com")]
9529 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V4_A {}
9530 #[cfg(feature = "Win32_System_Com")]
9531 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V4_A {
9532     type Abi = Self;
9533     type DefaultType = Self;
9534 }
9535 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9536 #[repr(C)]
9537 pub union RPC_SECURITY_QOS_V4_A_0 {
9538     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_A,
9539 }
9540 impl RPC_SECURITY_QOS_V4_A_0 {}
9541 impl ::std::default::Default for RPC_SECURITY_QOS_V4_A_0 {
default() -> Self9542     fn default() -> Self {
9543         unsafe { ::std::mem::zeroed() }
9544     }
9545 }
9546 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V4_A_0 {
eq(&self, _other: &Self) -> bool9547     fn eq(&self, _other: &Self) -> bool {
9548         unimplemented!()
9549     }
9550 }
9551 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V4_A_0 {}
9552 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V4_A_0 {
9553     type Abi = Self;
9554     type DefaultType = Self;
9555 }
9556 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9557 #[repr(C)]
9558 #[cfg(feature = "Win32_System_Com")]
9559 pub struct RPC_SECURITY_QOS_V4_W {
9560     pub Version: u32,
9561     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9562     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9563     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9564     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9565     pub u: RPC_SECURITY_QOS_V4_W_0,
9566     pub Sid: *mut ::std::ffi::c_void,
9567     pub EffectiveOnly: u32,
9568 }
9569 #[cfg(feature = "Win32_System_Com")]
9570 impl RPC_SECURITY_QOS_V4_W {}
9571 #[cfg(feature = "Win32_System_Com")]
9572 impl ::std::default::Default for RPC_SECURITY_QOS_V4_W {
default() -> Self9573     fn default() -> Self {
9574         unsafe { ::std::mem::zeroed() }
9575     }
9576 }
9577 #[cfg(feature = "Win32_System_Com")]
9578 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V4_W {
eq(&self, _other: &Self) -> bool9579     fn eq(&self, _other: &Self) -> bool {
9580         unimplemented!()
9581     }
9582 }
9583 #[cfg(feature = "Win32_System_Com")]
9584 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V4_W {}
9585 #[cfg(feature = "Win32_System_Com")]
9586 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V4_W {
9587     type Abi = Self;
9588     type DefaultType = Self;
9589 }
9590 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9591 #[repr(C)]
9592 pub union RPC_SECURITY_QOS_V4_W_0 {
9593     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_W,
9594 }
9595 impl RPC_SECURITY_QOS_V4_W_0 {}
9596 impl ::std::default::Default for RPC_SECURITY_QOS_V4_W_0 {
default() -> Self9597     fn default() -> Self {
9598         unsafe { ::std::mem::zeroed() }
9599     }
9600 }
9601 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V4_W_0 {
eq(&self, _other: &Self) -> bool9602     fn eq(&self, _other: &Self) -> bool {
9603         unimplemented!()
9604     }
9605 }
9606 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V4_W_0 {}
9607 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V4_W_0 {
9608     type Abi = Self;
9609     type DefaultType = Self;
9610 }
9611 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9612 #[repr(C)]
9613 #[cfg(feature = "Win32_System_Com")]
9614 pub struct RPC_SECURITY_QOS_V5_A {
9615     pub Version: u32,
9616     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9617     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9618     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9619     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9620     pub u: RPC_SECURITY_QOS_V5_A_0,
9621     pub Sid: *mut ::std::ffi::c_void,
9622     pub EffectiveOnly: u32,
9623     pub ServerSecurityDescriptor: *mut ::std::ffi::c_void,
9624 }
9625 #[cfg(feature = "Win32_System_Com")]
9626 impl RPC_SECURITY_QOS_V5_A {}
9627 #[cfg(feature = "Win32_System_Com")]
9628 impl ::std::default::Default for RPC_SECURITY_QOS_V5_A {
default() -> Self9629     fn default() -> Self {
9630         unsafe { ::std::mem::zeroed() }
9631     }
9632 }
9633 #[cfg(feature = "Win32_System_Com")]
9634 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V5_A {
eq(&self, _other: &Self) -> bool9635     fn eq(&self, _other: &Self) -> bool {
9636         unimplemented!()
9637     }
9638 }
9639 #[cfg(feature = "Win32_System_Com")]
9640 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V5_A {}
9641 #[cfg(feature = "Win32_System_Com")]
9642 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V5_A {
9643     type Abi = Self;
9644     type DefaultType = Self;
9645 }
9646 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9647 #[repr(C)]
9648 pub union RPC_SECURITY_QOS_V5_A_0 {
9649     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_A,
9650 }
9651 impl RPC_SECURITY_QOS_V5_A_0 {}
9652 impl ::std::default::Default for RPC_SECURITY_QOS_V5_A_0 {
default() -> Self9653     fn default() -> Self {
9654         unsafe { ::std::mem::zeroed() }
9655     }
9656 }
9657 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V5_A_0 {
eq(&self, _other: &Self) -> bool9658     fn eq(&self, _other: &Self) -> bool {
9659         unimplemented!()
9660     }
9661 }
9662 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V5_A_0 {}
9663 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V5_A_0 {
9664     type Abi = Self;
9665     type DefaultType = Self;
9666 }
9667 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9668 #[repr(C)]
9669 #[cfg(feature = "Win32_System_Com")]
9670 pub struct RPC_SECURITY_QOS_V5_W {
9671     pub Version: u32,
9672     pub Capabilities: RPC_C_QOS_CAPABILITIES,
9673     pub IdentityTracking: RPC_C_QOS_IDENTITY,
9674     pub ImpersonationType: super::Com::RPC_C_IMP_LEVEL,
9675     pub AdditionalSecurityInfoType: RPC_C_AUTHN_INFO_TYPE,
9676     pub u: RPC_SECURITY_QOS_V5_W_0,
9677     pub Sid: *mut ::std::ffi::c_void,
9678     pub EffectiveOnly: u32,
9679     pub ServerSecurityDescriptor: *mut ::std::ffi::c_void,
9680 }
9681 #[cfg(feature = "Win32_System_Com")]
9682 impl RPC_SECURITY_QOS_V5_W {}
9683 #[cfg(feature = "Win32_System_Com")]
9684 impl ::std::default::Default for RPC_SECURITY_QOS_V5_W {
default() -> Self9685     fn default() -> Self {
9686         unsafe { ::std::mem::zeroed() }
9687     }
9688 }
9689 #[cfg(feature = "Win32_System_Com")]
9690 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V5_W {
eq(&self, _other: &Self) -> bool9691     fn eq(&self, _other: &Self) -> bool {
9692         unimplemented!()
9693     }
9694 }
9695 #[cfg(feature = "Win32_System_Com")]
9696 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V5_W {}
9697 #[cfg(feature = "Win32_System_Com")]
9698 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V5_W {
9699     type Abi = Self;
9700     type DefaultType = Self;
9701 }
9702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9703 #[repr(C)]
9704 pub union RPC_SECURITY_QOS_V5_W_0 {
9705     pub HttpCredentials: *mut RPC_HTTP_TRANSPORT_CREDENTIALS_W,
9706 }
9707 impl RPC_SECURITY_QOS_V5_W_0 {}
9708 impl ::std::default::Default for RPC_SECURITY_QOS_V5_W_0 {
default() -> Self9709     fn default() -> Self {
9710         unsafe { ::std::mem::zeroed() }
9711     }
9712 }
9713 impl ::std::cmp::PartialEq for RPC_SECURITY_QOS_V5_W_0 {
eq(&self, _other: &Self) -> bool9714     fn eq(&self, _other: &Self) -> bool {
9715         unimplemented!()
9716     }
9717 }
9718 impl ::std::cmp::Eq for RPC_SECURITY_QOS_V5_W_0 {}
9719 unsafe impl ::windows::runtime::Abi for RPC_SECURITY_QOS_V5_W_0 {
9720     type Abi = Self;
9721     type DefaultType = Self;
9722 }
9723 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9724 #[repr(C)]
9725 pub struct RPC_SEC_CONTEXT_KEY_INFO {
9726     pub EncryptAlgorithm: u32,
9727     pub KeySize: u32,
9728     pub SignatureAlgorithm: u32,
9729 }
9730 impl RPC_SEC_CONTEXT_KEY_INFO {}
9731 impl ::std::default::Default for RPC_SEC_CONTEXT_KEY_INFO {
default() -> Self9732     fn default() -> Self {
9733         unsafe { ::std::mem::zeroed() }
9734     }
9735 }
9736 impl ::std::fmt::Debug for RPC_SEC_CONTEXT_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9737     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9738         fmt.debug_struct("RPC_SEC_CONTEXT_KEY_INFO").field("EncryptAlgorithm", &self.EncryptAlgorithm).field("KeySize", &self.KeySize).field("SignatureAlgorithm", &self.SignatureAlgorithm).finish()
9739     }
9740 }
9741 impl ::std::cmp::PartialEq for RPC_SEC_CONTEXT_KEY_INFO {
eq(&self, other: &Self) -> bool9742     fn eq(&self, other: &Self) -> bool {
9743         self.EncryptAlgorithm == other.EncryptAlgorithm && self.KeySize == other.KeySize && self.SignatureAlgorithm == other.SignatureAlgorithm
9744     }
9745 }
9746 impl ::std::cmp::Eq for RPC_SEC_CONTEXT_KEY_INFO {}
9747 unsafe impl ::windows::runtime::Abi for RPC_SEC_CONTEXT_KEY_INFO {
9748     type Abi = Self;
9749     type DefaultType = Self;
9750 }
9751 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9752 #[repr(C)]
9753 pub struct RPC_SERVER_INTERFACE {
9754     pub Length: u32,
9755     pub InterfaceId: RPC_SYNTAX_IDENTIFIER,
9756     pub TransferSyntax: RPC_SYNTAX_IDENTIFIER,
9757     pub DispatchTable: *mut RPC_DISPATCH_TABLE,
9758     pub RpcProtseqEndpointCount: u32,
9759     pub RpcProtseqEndpoint: *mut RPC_PROTSEQ_ENDPOINT,
9760     pub DefaultManagerEpv: *mut ::std::ffi::c_void,
9761     pub InterpreterInfo: *mut ::std::ffi::c_void,
9762     pub Flags: u32,
9763 }
9764 impl RPC_SERVER_INTERFACE {}
9765 impl ::std::default::Default for RPC_SERVER_INTERFACE {
default() -> Self9766     fn default() -> Self {
9767         unsafe { ::std::mem::zeroed() }
9768     }
9769 }
9770 impl ::std::fmt::Debug for RPC_SERVER_INTERFACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9771     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9772         fmt.debug_struct("RPC_SERVER_INTERFACE")
9773             .field("Length", &self.Length)
9774             .field("InterfaceId", &self.InterfaceId)
9775             .field("TransferSyntax", &self.TransferSyntax)
9776             .field("DispatchTable", &self.DispatchTable)
9777             .field("RpcProtseqEndpointCount", &self.RpcProtseqEndpointCount)
9778             .field("RpcProtseqEndpoint", &self.RpcProtseqEndpoint)
9779             .field("DefaultManagerEpv", &self.DefaultManagerEpv)
9780             .field("InterpreterInfo", &self.InterpreterInfo)
9781             .field("Flags", &self.Flags)
9782             .finish()
9783     }
9784 }
9785 impl ::std::cmp::PartialEq for RPC_SERVER_INTERFACE {
eq(&self, other: &Self) -> bool9786     fn eq(&self, other: &Self) -> bool {
9787         self.Length == other.Length && self.InterfaceId == other.InterfaceId && self.TransferSyntax == other.TransferSyntax && self.DispatchTable == other.DispatchTable && self.RpcProtseqEndpointCount == other.RpcProtseqEndpointCount && self.RpcProtseqEndpoint == other.RpcProtseqEndpoint && self.DefaultManagerEpv == other.DefaultManagerEpv && self.InterpreterInfo == other.InterpreterInfo && self.Flags == other.Flags
9788     }
9789 }
9790 impl ::std::cmp::Eq for RPC_SERVER_INTERFACE {}
9791 unsafe impl ::windows::runtime::Abi for RPC_SERVER_INTERFACE {
9792     type Abi = Self;
9793     type DefaultType = Self;
9794 }
9795 pub type RPC_SETFILTER_FUNC = unsafe extern "system" fn(pfnfilter: ::windows::runtime::RawPtr);
9796 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9797 #[repr(C)]
9798 pub struct RPC_STATS_VECTOR {
9799     pub Count: u32,
9800     pub Stats: [u32; 1],
9801 }
9802 impl RPC_STATS_VECTOR {}
9803 impl ::std::default::Default for RPC_STATS_VECTOR {
default() -> Self9804     fn default() -> Self {
9805         unsafe { ::std::mem::zeroed() }
9806     }
9807 }
9808 impl ::std::fmt::Debug for RPC_STATS_VECTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9809     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9810         fmt.debug_struct("RPC_STATS_VECTOR").field("Count", &self.Count).field("Stats", &self.Stats).finish()
9811     }
9812 }
9813 impl ::std::cmp::PartialEq for RPC_STATS_VECTOR {
eq(&self, other: &Self) -> bool9814     fn eq(&self, other: &Self) -> bool {
9815         self.Count == other.Count && self.Stats == other.Stats
9816     }
9817 }
9818 impl ::std::cmp::Eq for RPC_STATS_VECTOR {}
9819 unsafe impl ::windows::runtime::Abi for RPC_STATS_VECTOR {
9820     type Abi = Self;
9821     type DefaultType = Self;
9822 }
9823 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9824 #[repr(transparent)]
9825 pub struct RPC_STATUS(pub i32);
9826 pub const RPC_S_INVALID_STRING_BINDING: RPC_STATUS = RPC_STATUS(1700i32);
9827 pub const RPC_S_WRONG_KIND_OF_BINDING: RPC_STATUS = RPC_STATUS(1701i32);
9828 pub const RPC_S_INVALID_BINDING: RPC_STATUS = RPC_STATUS(1702i32);
9829 pub const RPC_S_PROTSEQ_NOT_SUPPORTED: RPC_STATUS = RPC_STATUS(1703i32);
9830 pub const RPC_S_INVALID_RPC_PROTSEQ: RPC_STATUS = RPC_STATUS(1704i32);
9831 pub const RPC_S_INVALID_STRING_UUID: RPC_STATUS = RPC_STATUS(1705i32);
9832 pub const RPC_S_INVALID_ENDPOINT_FORMAT: RPC_STATUS = RPC_STATUS(1706i32);
9833 pub const RPC_S_INVALID_NET_ADDR: RPC_STATUS = RPC_STATUS(1707i32);
9834 pub const RPC_S_NO_ENDPOINT_FOUND: RPC_STATUS = RPC_STATUS(1708i32);
9835 pub const RPC_S_INVALID_TIMEOUT: RPC_STATUS = RPC_STATUS(1709i32);
9836 pub const RPC_S_OBJECT_NOT_FOUND: RPC_STATUS = RPC_STATUS(1710i32);
9837 pub const RPC_S_ALREADY_REGISTERED: RPC_STATUS = RPC_STATUS(1711i32);
9838 pub const RPC_S_TYPE_ALREADY_REGISTERED: RPC_STATUS = RPC_STATUS(1712i32);
9839 pub const RPC_S_ALREADY_LISTENING: RPC_STATUS = RPC_STATUS(1713i32);
9840 pub const RPC_S_NO_PROTSEQS_REGISTERED: RPC_STATUS = RPC_STATUS(1714i32);
9841 pub const RPC_S_NOT_LISTENING: RPC_STATUS = RPC_STATUS(1715i32);
9842 pub const RPC_S_UNKNOWN_MGR_TYPE: RPC_STATUS = RPC_STATUS(1716i32);
9843 pub const RPC_S_UNKNOWN_IF: RPC_STATUS = RPC_STATUS(1717i32);
9844 pub const RPC_S_NO_BINDINGS: RPC_STATUS = RPC_STATUS(1718i32);
9845 pub const RPC_S_NO_PROTSEQS: RPC_STATUS = RPC_STATUS(1719i32);
9846 pub const RPC_S_CANT_CREATE_ENDPOINT: RPC_STATUS = RPC_STATUS(1720i32);
9847 pub const RPC_S_OUT_OF_RESOURCES: RPC_STATUS = RPC_STATUS(1721i32);
9848 pub const RPC_S_SERVER_UNAVAILABLE: RPC_STATUS = RPC_STATUS(1722i32);
9849 pub const RPC_S_SERVER_TOO_BUSY: RPC_STATUS = RPC_STATUS(1723i32);
9850 pub const RPC_S_INVALID_NETWORK_OPTIONS: RPC_STATUS = RPC_STATUS(1724i32);
9851 pub const RPC_S_NO_CALL_ACTIVE: RPC_STATUS = RPC_STATUS(1725i32);
9852 pub const RPC_S_CALL_FAILED: RPC_STATUS = RPC_STATUS(1726i32);
9853 pub const RPC_S_CALL_FAILED_DNE: RPC_STATUS = RPC_STATUS(1727i32);
9854 pub const RPC_S_PROTOCOL_ERROR: RPC_STATUS = RPC_STATUS(1728i32);
9855 pub const RPC_S_PROXY_ACCESS_DENIED: RPC_STATUS = RPC_STATUS(1729i32);
9856 pub const RPC_S_UNSUPPORTED_TRANS_SYN: RPC_STATUS = RPC_STATUS(1730i32);
9857 pub const RPC_S_UNSUPPORTED_TYPE: RPC_STATUS = RPC_STATUS(1732i32);
9858 pub const RPC_S_INVALID_TAG: RPC_STATUS = RPC_STATUS(1733i32);
9859 pub const RPC_S_INVALID_BOUND: RPC_STATUS = RPC_STATUS(1734i32);
9860 pub const RPC_S_NO_ENTRY_NAME: RPC_STATUS = RPC_STATUS(1735i32);
9861 pub const RPC_S_INVALID_NAME_SYNTAX: RPC_STATUS = RPC_STATUS(1736i32);
9862 pub const RPC_S_UNSUPPORTED_NAME_SYNTAX: RPC_STATUS = RPC_STATUS(1737i32);
9863 pub const RPC_S_UUID_NO_ADDRESS: RPC_STATUS = RPC_STATUS(1739i32);
9864 pub const RPC_S_DUPLICATE_ENDPOINT: RPC_STATUS = RPC_STATUS(1740i32);
9865 pub const RPC_S_UNKNOWN_AUTHN_TYPE: RPC_STATUS = RPC_STATUS(1741i32);
9866 pub const RPC_S_MAX_CALLS_TOO_SMALL: RPC_STATUS = RPC_STATUS(1742i32);
9867 pub const RPC_S_STRING_TOO_LONG: RPC_STATUS = RPC_STATUS(1743i32);
9868 pub const RPC_S_PROTSEQ_NOT_FOUND: RPC_STATUS = RPC_STATUS(1744i32);
9869 pub const RPC_S_PROCNUM_OUT_OF_RANGE: RPC_STATUS = RPC_STATUS(1745i32);
9870 pub const RPC_S_BINDING_HAS_NO_AUTH: RPC_STATUS = RPC_STATUS(1746i32);
9871 pub const RPC_S_UNKNOWN_AUTHN_SERVICE: RPC_STATUS = RPC_STATUS(1747i32);
9872 pub const RPC_S_UNKNOWN_AUTHN_LEVEL: RPC_STATUS = RPC_STATUS(1748i32);
9873 pub const RPC_S_INVALID_AUTH_IDENTITY: RPC_STATUS = RPC_STATUS(1749i32);
9874 pub const RPC_S_UNKNOWN_AUTHZ_SERVICE: RPC_STATUS = RPC_STATUS(1750i32);
9875 pub const EPT_S_INVALID_ENTRY: RPC_STATUS = RPC_STATUS(1751i32);
9876 pub const EPT_S_CANT_PERFORM_OP: RPC_STATUS = RPC_STATUS(1752i32);
9877 pub const EPT_S_NOT_REGISTERED: RPC_STATUS = RPC_STATUS(1753i32);
9878 pub const RPC_S_NOTHING_TO_EXPORT: RPC_STATUS = RPC_STATUS(1754i32);
9879 pub const RPC_S_INCOMPLETE_NAME: RPC_STATUS = RPC_STATUS(1755i32);
9880 pub const RPC_S_INVALID_VERS_OPTION: RPC_STATUS = RPC_STATUS(1756i32);
9881 pub const RPC_S_NO_MORE_MEMBERS: RPC_STATUS = RPC_STATUS(1757i32);
9882 pub const RPC_S_NOT_ALL_OBJS_UNEXPORTED: RPC_STATUS = RPC_STATUS(1758i32);
9883 pub const RPC_S_INTERFACE_NOT_FOUND: RPC_STATUS = RPC_STATUS(1759i32);
9884 pub const RPC_S_ENTRY_ALREADY_EXISTS: RPC_STATUS = RPC_STATUS(1760i32);
9885 pub const RPC_S_ENTRY_NOT_FOUND: RPC_STATUS = RPC_STATUS(1761i32);
9886 pub const RPC_S_NAME_SERVICE_UNAVAILABLE: RPC_STATUS = RPC_STATUS(1762i32);
9887 pub const RPC_S_INVALID_NAF_ID: RPC_STATUS = RPC_STATUS(1763i32);
9888 pub const RPC_S_CANNOT_SUPPORT: RPC_STATUS = RPC_STATUS(1764i32);
9889 pub const RPC_S_NO_CONTEXT_AVAILABLE: RPC_STATUS = RPC_STATUS(1765i32);
9890 pub const RPC_S_INTERNAL_ERROR: RPC_STATUS = RPC_STATUS(1766i32);
9891 pub const RPC_S_ZERO_DIVIDE: RPC_STATUS = RPC_STATUS(1767i32);
9892 pub const RPC_S_ADDRESS_ERROR: RPC_STATUS = RPC_STATUS(1768i32);
9893 pub const RPC_S_FP_DIV_ZERO: RPC_STATUS = RPC_STATUS(1769i32);
9894 pub const RPC_S_FP_UNDERFLOW: RPC_STATUS = RPC_STATUS(1770i32);
9895 pub const RPC_S_FP_OVERFLOW: RPC_STATUS = RPC_STATUS(1771i32);
9896 pub const RPC_S_CALL_IN_PROGRESS: RPC_STATUS = RPC_STATUS(1791i32);
9897 pub const RPC_S_NO_MORE_BINDINGS: RPC_STATUS = RPC_STATUS(1806i32);
9898 pub const RPC_S_NO_INTERFACES: RPC_STATUS = RPC_STATUS(1817i32);
9899 pub const RPC_S_CALL_CANCELLED: RPC_STATUS = RPC_STATUS(1818i32);
9900 pub const RPC_S_BINDING_INCOMPLETE: RPC_STATUS = RPC_STATUS(1819i32);
9901 pub const RPC_S_COMM_FAILURE: RPC_STATUS = RPC_STATUS(1820i32);
9902 pub const RPC_S_UNSUPPORTED_AUTHN_LEVEL: RPC_STATUS = RPC_STATUS(1821i32);
9903 pub const RPC_S_NO_PRINC_NAME: RPC_STATUS = RPC_STATUS(1822i32);
9904 pub const RPC_S_NOT_RPC_ERROR: RPC_STATUS = RPC_STATUS(1823i32);
9905 pub const RPC_S_UUID_LOCAL_ONLY: RPC_STATUS = RPC_STATUS(1824i32);
9906 pub const RPC_S_SEC_PKG_ERROR: RPC_STATUS = RPC_STATUS(1825i32);
9907 pub const RPC_S_NOT_CANCELLED: RPC_STATUS = RPC_STATUS(1826i32);
9908 pub const RPC_S_COOKIE_AUTH_FAILED: RPC_STATUS = RPC_STATUS(1833i32);
9909 pub const RPC_S_DO_NOT_DISTURB: RPC_STATUS = RPC_STATUS(1834i32);
9910 pub const RPC_S_SYSTEM_HANDLE_COUNT_EXCEEDED: RPC_STATUS = RPC_STATUS(1835i32);
9911 pub const RPC_S_SYSTEM_HANDLE_TYPE_MISMATCH: RPC_STATUS = RPC_STATUS(1836i32);
9912 pub const RPC_S_GROUP_MEMBER_NOT_FOUND: RPC_STATUS = RPC_STATUS(1898i32);
9913 pub const EPT_S_CANT_CREATE: RPC_STATUS = RPC_STATUS(1899i32);
9914 pub const RPC_S_INVALID_OBJECT: RPC_STATUS = RPC_STATUS(1900i32);
9915 pub const RPC_S_SEND_INCOMPLETE: RPC_STATUS = RPC_STATUS(1913i32);
9916 pub const RPC_S_INVALID_ASYNC_HANDLE: RPC_STATUS = RPC_STATUS(1914i32);
9917 pub const RPC_S_INVALID_ASYNC_CALL: RPC_STATUS = RPC_STATUS(1915i32);
9918 pub const RPC_S_ENTRY_TYPE_MISMATCH: RPC_STATUS = RPC_STATUS(1922i32);
9919 pub const RPC_S_NOT_ALL_OBJS_EXPORTED: RPC_STATUS = RPC_STATUS(1923i32);
9920 pub const RPC_S_INTERFACE_NOT_EXPORTED: RPC_STATUS = RPC_STATUS(1924i32);
9921 pub const RPC_S_PROFILE_NOT_ADDED: RPC_STATUS = RPC_STATUS(1925i32);
9922 pub const RPC_S_PRF_ELT_NOT_ADDED: RPC_STATUS = RPC_STATUS(1926i32);
9923 pub const RPC_S_PRF_ELT_NOT_REMOVED: RPC_STATUS = RPC_STATUS(1927i32);
9924 pub const RPC_S_GRP_ELT_NOT_ADDED: RPC_STATUS = RPC_STATUS(1928i32);
9925 pub const RPC_S_GRP_ELT_NOT_REMOVED: RPC_STATUS = RPC_STATUS(1929i32);
9926 impl ::std::convert::From<i32> for RPC_STATUS {
from(value: i32) -> Self9927     fn from(value: i32) -> Self {
9928         Self(value)
9929     }
9930 }
9931 unsafe impl ::windows::runtime::Abi for RPC_STATUS {
9932     type Abi = Self;
9933     type DefaultType = Self;
9934 }
9935 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9936 #[repr(C)]
9937 pub struct RPC_SYNTAX_IDENTIFIER {
9938     pub SyntaxGUID: ::windows::runtime::GUID,
9939     pub SyntaxVersion: RPC_VERSION,
9940 }
9941 impl RPC_SYNTAX_IDENTIFIER {}
9942 impl ::std::default::Default for RPC_SYNTAX_IDENTIFIER {
default() -> Self9943     fn default() -> Self {
9944         unsafe { ::std::mem::zeroed() }
9945     }
9946 }
9947 impl ::std::fmt::Debug for RPC_SYNTAX_IDENTIFIER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9948     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9949         fmt.debug_struct("RPC_SYNTAX_IDENTIFIER").field("SyntaxGUID", &self.SyntaxGUID).field("SyntaxVersion", &self.SyntaxVersion).finish()
9950     }
9951 }
9952 impl ::std::cmp::PartialEq for RPC_SYNTAX_IDENTIFIER {
eq(&self, other: &Self) -> bool9953     fn eq(&self, other: &Self) -> bool {
9954         self.SyntaxGUID == other.SyntaxGUID && self.SyntaxVersion == other.SyntaxVersion
9955     }
9956 }
9957 impl ::std::cmp::Eq for RPC_SYNTAX_IDENTIFIER {}
9958 unsafe impl ::windows::runtime::Abi for RPC_SYNTAX_IDENTIFIER {
9959     type Abi = Self;
9960     type DefaultType = Self;
9961 }
9962 pub const RPC_SYSTEM_HANDLE_FREE_ALL: u32 = 3u32;
9963 pub const RPC_SYSTEM_HANDLE_FREE_ERROR_ON_CLOSE: u32 = 4u32;
9964 pub const RPC_SYSTEM_HANDLE_FREE_RETRIEVED: u32 = 2u32;
9965 pub const RPC_SYSTEM_HANDLE_FREE_UNRETRIEVED: u32 = 1u32;
9966 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9967 #[repr(C)]
9968 pub struct RPC_TRANSFER_SYNTAX {
9969     pub Uuid: ::windows::runtime::GUID,
9970     pub VersMajor: u16,
9971     pub VersMinor: u16,
9972 }
9973 impl RPC_TRANSFER_SYNTAX {}
9974 impl ::std::default::Default for RPC_TRANSFER_SYNTAX {
default() -> Self9975     fn default() -> Self {
9976         unsafe { ::std::mem::zeroed() }
9977     }
9978 }
9979 impl ::std::fmt::Debug for RPC_TRANSFER_SYNTAX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9980     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9981         fmt.debug_struct("RPC_TRANSFER_SYNTAX").field("Uuid", &self.Uuid).field("VersMajor", &self.VersMajor).field("VersMinor", &self.VersMinor).finish()
9982     }
9983 }
9984 impl ::std::cmp::PartialEq for RPC_TRANSFER_SYNTAX {
eq(&self, other: &Self) -> bool9985     fn eq(&self, other: &Self) -> bool {
9986         self.Uuid == other.Uuid && self.VersMajor == other.VersMajor && self.VersMinor == other.VersMinor
9987     }
9988 }
9989 impl ::std::cmp::Eq for RPC_TRANSFER_SYNTAX {}
9990 unsafe impl ::windows::runtime::Abi for RPC_TRANSFER_SYNTAX {
9991     type Abi = Self;
9992     type DefaultType = Self;
9993 }
9994 pub const RPC_TYPE_DISCONNECT_EVENT_CONTEXT_HANDLE: u32 = 2147483648u32;
9995 pub const RPC_TYPE_STRICT_CONTEXT_HANDLE: u32 = 1073741824u32;
9996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9997 #[repr(C)]
9998 pub struct RPC_VERSION {
9999     pub MajorVersion: u16,
10000     pub MinorVersion: u16,
10001 }
10002 impl RPC_VERSION {}
10003 impl ::std::default::Default for RPC_VERSION {
default() -> Self10004     fn default() -> Self {
10005         unsafe { ::std::mem::zeroed() }
10006     }
10007 }
10008 impl ::std::fmt::Debug for RPC_VERSION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10009     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10010         fmt.debug_struct("RPC_VERSION").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).finish()
10011     }
10012 }
10013 impl ::std::cmp::PartialEq for RPC_VERSION {
eq(&self, other: &Self) -> bool10014     fn eq(&self, other: &Self) -> bool {
10015         self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion
10016     }
10017 }
10018 impl ::std::cmp::Eq for RPC_VERSION {}
10019 unsafe impl ::windows::runtime::Abi for RPC_VERSION {
10020     type Abi = Self;
10021     type DefaultType = Self;
10022 }
10023 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10024 #[inline]
RpcAsyncAbortCall(pasync: *mut RPC_ASYNC_STATE, exceptioncode: u32) -> RPC_STATUS10025 pub unsafe fn RpcAsyncAbortCall(pasync: *mut RPC_ASYNC_STATE, exceptioncode: u32) -> RPC_STATUS {
10026     #[cfg(windows)]
10027     {
10028         #[link(name = "windows")]
10029         extern "system" {
10030             fn RpcAsyncAbortCall(pasync: *mut ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, exceptioncode: u32) -> RPC_STATUS;
10031         }
10032         ::std::mem::transmute(RpcAsyncAbortCall(::std::mem::transmute(pasync), ::std::mem::transmute(exceptioncode)))
10033     }
10034     #[cfg(not(windows))]
10035     unimplemented!("Unsupported target OS");
10036 }
10037 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10038 #[inline]
RpcAsyncCancelCall<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pasync: *mut RPC_ASYNC_STATE, fabort: Param1) -> RPC_STATUS10039 pub unsafe fn RpcAsyncCancelCall<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pasync: *mut RPC_ASYNC_STATE, fabort: Param1) -> RPC_STATUS {
10040     #[cfg(windows)]
10041     {
10042         #[link(name = "windows")]
10043         extern "system" {
10044             fn RpcAsyncCancelCall(pasync: *mut ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, fabort: super::super::Foundation::BOOL) -> RPC_STATUS;
10045         }
10046         ::std::mem::transmute(RpcAsyncCancelCall(::std::mem::transmute(pasync), fabort.into_param().abi()))
10047     }
10048     #[cfg(not(windows))]
10049     unimplemented!("Unsupported target OS");
10050 }
10051 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10052 #[inline]
RpcAsyncCompleteCall(pasync: *mut RPC_ASYNC_STATE, reply: *mut ::std::ffi::c_void) -> RPC_STATUS10053 pub unsafe fn RpcAsyncCompleteCall(pasync: *mut RPC_ASYNC_STATE, reply: *mut ::std::ffi::c_void) -> RPC_STATUS {
10054     #[cfg(windows)]
10055     {
10056         #[link(name = "windows")]
10057         extern "system" {
10058             fn RpcAsyncCompleteCall(pasync: *mut ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, reply: *mut ::std::ffi::c_void) -> RPC_STATUS;
10059         }
10060         ::std::mem::transmute(RpcAsyncCompleteCall(::std::mem::transmute(pasync), ::std::mem::transmute(reply)))
10061     }
10062     #[cfg(not(windows))]
10063     unimplemented!("Unsupported target OS");
10064 }
10065 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10066 #[inline]
RpcAsyncGetCallStatus(pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS10067 pub unsafe fn RpcAsyncGetCallStatus(pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS {
10068     #[cfg(windows)]
10069     {
10070         #[link(name = "windows")]
10071         extern "system" {
10072             fn RpcAsyncGetCallStatus(pasync: *const ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>) -> RPC_STATUS;
10073         }
10074         ::std::mem::transmute(RpcAsyncGetCallStatus(::std::mem::transmute(pasync)))
10075     }
10076     #[cfg(not(windows))]
10077     unimplemented!("Unsupported target OS");
10078 }
10079 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10080 #[inline]
RpcAsyncInitializeHandle(pasync: *mut RPC_ASYNC_STATE, size: u32) -> RPC_STATUS10081 pub unsafe fn RpcAsyncInitializeHandle(pasync: *mut RPC_ASYNC_STATE, size: u32) -> RPC_STATUS {
10082     #[cfg(windows)]
10083     {
10084         #[link(name = "windows")]
10085         extern "system" {
10086             fn RpcAsyncInitializeHandle(pasync: *mut ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, size: u32) -> RPC_STATUS;
10087         }
10088         ::std::mem::transmute(RpcAsyncInitializeHandle(::std::mem::transmute(pasync), ::std::mem::transmute(size)))
10089     }
10090     #[cfg(not(windows))]
10091     unimplemented!("Unsupported target OS");
10092 }
10093 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10094 #[inline]
RpcAsyncRegisterInfo(pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS10095 pub unsafe fn RpcAsyncRegisterInfo(pasync: *const RPC_ASYNC_STATE) -> RPC_STATUS {
10096     #[cfg(windows)]
10097     {
10098         #[link(name = "windows")]
10099         extern "system" {
10100             fn RpcAsyncRegisterInfo(pasync: *const ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>) -> RPC_STATUS;
10101         }
10102         ::std::mem::transmute(RpcAsyncRegisterInfo(::std::mem::transmute(pasync)))
10103     }
10104     #[cfg(not(windows))]
10105     unimplemented!("Unsupported target OS");
10106 }
10107 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10108 #[inline]
RpcBindingBind(pasync: *const RPC_ASYNC_STATE, binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS10109 pub unsafe fn RpcBindingBind(pasync: *const RPC_ASYNC_STATE, binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS {
10110     #[cfg(windows)]
10111     {
10112         #[link(name = "windows")]
10113         extern "system" {
10114             fn RpcBindingBind(pasync: *const ::std::mem::ManuallyDrop<RPC_ASYNC_STATE>, binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS;
10115         }
10116         ::std::mem::transmute(RpcBindingBind(::std::mem::transmute(pasync), ::std::mem::transmute(binding), ::std::mem::transmute(ifspec)))
10117     }
10118     #[cfg(not(windows))]
10119     unimplemented!("Unsupported target OS");
10120 }
10121 #[inline]
RpcBindingCopy(sourcebinding: *const ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10122 pub unsafe fn RpcBindingCopy(sourcebinding: *const ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10123     #[cfg(windows)]
10124     {
10125         #[link(name = "windows")]
10126         extern "system" {
10127             fn RpcBindingCopy(sourcebinding: *const ::std::ffi::c_void, destinationbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10128         }
10129         ::std::mem::transmute(RpcBindingCopy(::std::mem::transmute(sourcebinding), ::std::mem::transmute(destinationbinding)))
10130     }
10131     #[cfg(not(windows))]
10132     unimplemented!("Unsupported target OS");
10133 }
10134 #[cfg(feature = "Win32_System_Com")]
10135 #[inline]
RpcBindingCreateA(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_A, security: *const RPC_BINDING_HANDLE_SECURITY_V1_A, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10136 pub unsafe fn RpcBindingCreateA(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_A, security: *const RPC_BINDING_HANDLE_SECURITY_V1_A, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10137     #[cfg(windows)]
10138     {
10139         #[link(name = "windows")]
10140         extern "system" {
10141             fn RpcBindingCreateA(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_A, security: *const RPC_BINDING_HANDLE_SECURITY_V1_A, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10142         }
10143         ::std::mem::transmute(RpcBindingCreateA(::std::mem::transmute(template), ::std::mem::transmute(security), ::std::mem::transmute(options), ::std::mem::transmute(binding)))
10144     }
10145     #[cfg(not(windows))]
10146     unimplemented!("Unsupported target OS");
10147 }
10148 #[cfg(feature = "Win32_System_Com")]
10149 #[inline]
RpcBindingCreateW(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_W, security: *const RPC_BINDING_HANDLE_SECURITY_V1_W, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10150 pub unsafe fn RpcBindingCreateW(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_W, security: *const RPC_BINDING_HANDLE_SECURITY_V1_W, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10151     #[cfg(windows)]
10152     {
10153         #[link(name = "windows")]
10154         extern "system" {
10155             fn RpcBindingCreateW(template: *const RPC_BINDING_HANDLE_TEMPLATE_V1_W, security: *const RPC_BINDING_HANDLE_SECURITY_V1_W, options: *const RPC_BINDING_HANDLE_OPTIONS_V1, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10156         }
10157         ::std::mem::transmute(RpcBindingCreateW(::std::mem::transmute(template), ::std::mem::transmute(security), ::std::mem::transmute(options), ::std::mem::transmute(binding)))
10158     }
10159     #[cfg(not(windows))]
10160     unimplemented!("Unsupported target OS");
10161 }
10162 #[inline]
RpcBindingFree(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10163 pub unsafe fn RpcBindingFree(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10164     #[cfg(windows)]
10165     {
10166         #[link(name = "windows")]
10167         extern "system" {
10168             fn RpcBindingFree(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10169         }
10170         ::std::mem::transmute(RpcBindingFree(::std::mem::transmute(binding)))
10171     }
10172     #[cfg(not(windows))]
10173     unimplemented!("Unsupported target OS");
10174 }
10175 #[inline]
RpcBindingFromStringBindingA(stringbinding: *const u8, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10176 pub unsafe fn RpcBindingFromStringBindingA(stringbinding: *const u8, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10177     #[cfg(windows)]
10178     {
10179         #[link(name = "windows")]
10180         extern "system" {
10181             fn RpcBindingFromStringBindingA(stringbinding: *const u8, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10182         }
10183         ::std::mem::transmute(RpcBindingFromStringBindingA(::std::mem::transmute(stringbinding), ::std::mem::transmute(binding)))
10184     }
10185     #[cfg(not(windows))]
10186     unimplemented!("Unsupported target OS");
10187 }
10188 #[inline]
RpcBindingFromStringBindingW(stringbinding: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10189 pub unsafe fn RpcBindingFromStringBindingW(stringbinding: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10190     #[cfg(windows)]
10191     {
10192         #[link(name = "windows")]
10193         extern "system" {
10194             fn RpcBindingFromStringBindingW(stringbinding: *const u16, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10195         }
10196         ::std::mem::transmute(RpcBindingFromStringBindingW(::std::mem::transmute(stringbinding), ::std::mem::transmute(binding)))
10197     }
10198     #[cfg(not(windows))]
10199     unimplemented!("Unsupported target OS");
10200 }
10201 #[inline]
RpcBindingInqAuthClientA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS10202 pub unsafe fn RpcBindingInqAuthClientA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS {
10203     #[cfg(windows)]
10204     {
10205         #[link(name = "windows")]
10206         extern "system" {
10207             fn RpcBindingInqAuthClientA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS;
10208         }
10209         ::std::mem::transmute(RpcBindingInqAuthClientA(::std::mem::transmute(clientbinding), ::std::mem::transmute(privs), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authzsvc)))
10210     }
10211     #[cfg(not(windows))]
10212     unimplemented!("Unsupported target OS");
10213 }
10214 #[inline]
RpcBindingInqAuthClientExA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS10215 pub unsafe fn RpcBindingInqAuthClientExA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS {
10216     #[cfg(windows)]
10217     {
10218         #[link(name = "windows")]
10219         extern "system" {
10220             fn RpcBindingInqAuthClientExA(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS;
10221         }
10222         ::std::mem::transmute(RpcBindingInqAuthClientExA(::std::mem::transmute(clientbinding), ::std::mem::transmute(privs), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authzsvc), ::std::mem::transmute(flags)))
10223     }
10224     #[cfg(not(windows))]
10225     unimplemented!("Unsupported target OS");
10226 }
10227 #[inline]
RpcBindingInqAuthClientExW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS10228 pub unsafe fn RpcBindingInqAuthClientExW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS {
10229     #[cfg(windows)]
10230     {
10231         #[link(name = "windows")]
10232         extern "system" {
10233             fn RpcBindingInqAuthClientExW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32, flags: u32) -> RPC_STATUS;
10234         }
10235         ::std::mem::transmute(RpcBindingInqAuthClientExW(::std::mem::transmute(clientbinding), ::std::mem::transmute(privs), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authzsvc), ::std::mem::transmute(flags)))
10236     }
10237     #[cfg(not(windows))]
10238     unimplemented!("Unsupported target OS");
10239 }
10240 #[inline]
RpcBindingInqAuthClientW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS10241 pub unsafe fn RpcBindingInqAuthClientW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS {
10242     #[cfg(windows)]
10243     {
10244         #[link(name = "windows")]
10245         extern "system" {
10246             fn RpcBindingInqAuthClientW(clientbinding: *const ::std::ffi::c_void, privs: *mut *mut ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authzsvc: *mut u32) -> RPC_STATUS;
10247         }
10248         ::std::mem::transmute(RpcBindingInqAuthClientW(::std::mem::transmute(clientbinding), ::std::mem::transmute(privs), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authzsvc)))
10249     }
10250     #[cfg(not(windows))]
10251     unimplemented!("Unsupported target OS");
10252 }
10253 #[inline]
RpcBindingInqAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS10254 pub unsafe fn RpcBindingInqAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS {
10255     #[cfg(windows)]
10256     {
10257         #[link(name = "windows")]
10258         extern "system" {
10259             fn RpcBindingInqAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS;
10260         }
10261         ::std::mem::transmute(RpcBindingInqAuthInfoA(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc)))
10262     }
10263     #[cfg(not(windows))]
10264     unimplemented!("Unsupported target OS");
10265 }
10266 #[cfg(feature = "Win32_System_Com")]
10267 #[inline]
RpcBindingInqAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS10268 pub unsafe fn RpcBindingInqAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS {
10269     #[cfg(windows)]
10270     {
10271         #[link(name = "windows")]
10272         extern "system" {
10273             fn RpcBindingInqAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u8, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS;
10274         }
10275         ::std::mem::transmute(RpcBindingInqAuthInfoExA(
10276             ::std::mem::transmute(binding),
10277             ::std::mem::transmute(serverprincname),
10278             ::std::mem::transmute(authnlevel),
10279             ::std::mem::transmute(authnsvc),
10280             ::std::mem::transmute(authidentity),
10281             ::std::mem::transmute(authzsvc),
10282             ::std::mem::transmute(rpcqosversion),
10283             ::std::mem::transmute(securityqos),
10284         ))
10285     }
10286     #[cfg(not(windows))]
10287     unimplemented!("Unsupported target OS");
10288 }
10289 #[cfg(feature = "Win32_System_Com")]
10290 #[inline]
RpcBindingInqAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS10291 pub unsafe fn RpcBindingInqAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS {
10292     #[cfg(windows)]
10293     {
10294         #[link(name = "windows")]
10295         extern "system" {
10296             fn RpcBindingInqAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32, rpcqosversion: u32, securityqos: *mut RPC_SECURITY_QOS) -> RPC_STATUS;
10297         }
10298         ::std::mem::transmute(RpcBindingInqAuthInfoExW(
10299             ::std::mem::transmute(binding),
10300             ::std::mem::transmute(serverprincname),
10301             ::std::mem::transmute(authnlevel),
10302             ::std::mem::transmute(authnsvc),
10303             ::std::mem::transmute(authidentity),
10304             ::std::mem::transmute(authzsvc),
10305             ::std::mem::transmute(rpcqosversion),
10306             ::std::mem::transmute(securityqos),
10307         ))
10308     }
10309     #[cfg(not(windows))]
10310     unimplemented!("Unsupported target OS");
10311 }
10312 #[inline]
RpcBindingInqAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS10313 pub unsafe fn RpcBindingInqAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS {
10314     #[cfg(windows)]
10315     {
10316         #[link(name = "windows")]
10317         extern "system" {
10318             fn RpcBindingInqAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *mut *mut u16, authnlevel: *mut u32, authnsvc: *mut u32, authidentity: *mut *mut ::std::ffi::c_void, authzsvc: *mut u32) -> RPC_STATUS;
10319         }
10320         ::std::mem::transmute(RpcBindingInqAuthInfoW(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc)))
10321     }
10322     #[cfg(not(windows))]
10323     unimplemented!("Unsupported target OS");
10324 }
10325 #[inline]
RpcBindingInqMaxCalls(binding: *const ::std::ffi::c_void, maxcalls: *mut u32) -> RPC_STATUS10326 pub unsafe fn RpcBindingInqMaxCalls(binding: *const ::std::ffi::c_void, maxcalls: *mut u32) -> RPC_STATUS {
10327     #[cfg(windows)]
10328     {
10329         #[link(name = "windows")]
10330         extern "system" {
10331             fn RpcBindingInqMaxCalls(binding: *const ::std::ffi::c_void, maxcalls: *mut u32) -> RPC_STATUS;
10332         }
10333         ::std::mem::transmute(RpcBindingInqMaxCalls(::std::mem::transmute(binding), ::std::mem::transmute(maxcalls)))
10334     }
10335     #[cfg(not(windows))]
10336     unimplemented!("Unsupported target OS");
10337 }
10338 #[inline]
RpcBindingInqObject(binding: *const ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS10339 pub unsafe fn RpcBindingInqObject(binding: *const ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
10340     #[cfg(windows)]
10341     {
10342         #[link(name = "windows")]
10343         extern "system" {
10344             fn RpcBindingInqObject(binding: *const ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
10345         }
10346         ::std::mem::transmute(RpcBindingInqObject(::std::mem::transmute(binding), ::std::mem::transmute(objectuuid)))
10347     }
10348     #[cfg(not(windows))]
10349     unimplemented!("Unsupported target OS");
10350 }
10351 #[inline]
RpcBindingInqOption(hbinding: *const ::std::ffi::c_void, option: u32, poptionvalue: *mut usize) -> RPC_STATUS10352 pub unsafe fn RpcBindingInqOption(hbinding: *const ::std::ffi::c_void, option: u32, poptionvalue: *mut usize) -> RPC_STATUS {
10353     #[cfg(windows)]
10354     {
10355         #[link(name = "windows")]
10356         extern "system" {
10357             fn RpcBindingInqOption(hbinding: *const ::std::ffi::c_void, option: u32, poptionvalue: *mut usize) -> RPC_STATUS;
10358         }
10359         ::std::mem::transmute(RpcBindingInqOption(::std::mem::transmute(hbinding), ::std::mem::transmute(option), ::std::mem::transmute(poptionvalue)))
10360     }
10361     #[cfg(not(windows))]
10362     unimplemented!("Unsupported target OS");
10363 }
10364 #[inline]
RpcBindingReset(binding: *const ::std::ffi::c_void) -> RPC_STATUS10365 pub unsafe fn RpcBindingReset(binding: *const ::std::ffi::c_void) -> RPC_STATUS {
10366     #[cfg(windows)]
10367     {
10368         #[link(name = "windows")]
10369         extern "system" {
10370             fn RpcBindingReset(binding: *const ::std::ffi::c_void) -> RPC_STATUS;
10371         }
10372         ::std::mem::transmute(RpcBindingReset(::std::mem::transmute(binding)))
10373     }
10374     #[cfg(not(windows))]
10375     unimplemented!("Unsupported target OS");
10376 }
10377 #[inline]
RpcBindingServerFromClient(clientbinding: *const ::std::ffi::c_void, serverbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10378 pub unsafe fn RpcBindingServerFromClient(clientbinding: *const ::std::ffi::c_void, serverbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10379     #[cfg(windows)]
10380     {
10381         #[link(name = "windows")]
10382         extern "system" {
10383             fn RpcBindingServerFromClient(clientbinding: *const ::std::ffi::c_void, serverbinding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10384         }
10385         ::std::mem::transmute(RpcBindingServerFromClient(::std::mem::transmute(clientbinding), ::std::mem::transmute(serverbinding)))
10386     }
10387     #[cfg(not(windows))]
10388     unimplemented!("Unsupported target OS");
10389 }
10390 #[inline]
RpcBindingSetAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS10391 pub unsafe fn RpcBindingSetAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS {
10392     #[cfg(windows)]
10393     {
10394         #[link(name = "windows")]
10395         extern "system" {
10396             fn RpcBindingSetAuthInfoA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS;
10397         }
10398         ::std::mem::transmute(RpcBindingSetAuthInfoA(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc)))
10399     }
10400     #[cfg(not(windows))]
10401     unimplemented!("Unsupported target OS");
10402 }
10403 #[cfg(feature = "Win32_System_Com")]
10404 #[inline]
RpcBindingSetAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS10405 pub unsafe fn RpcBindingSetAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS {
10406     #[cfg(windows)]
10407     {
10408         #[link(name = "windows")]
10409         extern "system" {
10410             fn RpcBindingSetAuthInfoExA(binding: *const ::std::ffi::c_void, serverprincname: *const u8, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS;
10411         }
10412         ::std::mem::transmute(RpcBindingSetAuthInfoExA(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc), ::std::mem::transmute(securityqos)))
10413     }
10414     #[cfg(not(windows))]
10415     unimplemented!("Unsupported target OS");
10416 }
10417 #[cfg(feature = "Win32_System_Com")]
10418 #[inline]
RpcBindingSetAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS10419 pub unsafe fn RpcBindingSetAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS {
10420     #[cfg(windows)]
10421     {
10422         #[link(name = "windows")]
10423         extern "system" {
10424             fn RpcBindingSetAuthInfoExW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32, securityqos: *const RPC_SECURITY_QOS) -> RPC_STATUS;
10425         }
10426         ::std::mem::transmute(RpcBindingSetAuthInfoExW(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc), ::std::mem::transmute(securityqos)))
10427     }
10428     #[cfg(not(windows))]
10429     unimplemented!("Unsupported target OS");
10430 }
10431 #[inline]
RpcBindingSetAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS10432 pub unsafe fn RpcBindingSetAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS {
10433     #[cfg(windows)]
10434     {
10435         #[link(name = "windows")]
10436         extern "system" {
10437             fn RpcBindingSetAuthInfoW(binding: *const ::std::ffi::c_void, serverprincname: *const u16, authnlevel: u32, authnsvc: u32, authidentity: *const ::std::ffi::c_void, authzsvc: u32) -> RPC_STATUS;
10438         }
10439         ::std::mem::transmute(RpcBindingSetAuthInfoW(::std::mem::transmute(binding), ::std::mem::transmute(serverprincname), ::std::mem::transmute(authnlevel), ::std::mem::transmute(authnsvc), ::std::mem::transmute(authidentity), ::std::mem::transmute(authzsvc)))
10440     }
10441     #[cfg(not(windows))]
10442     unimplemented!("Unsupported target OS");
10443 }
10444 #[inline]
RpcBindingSetObject(binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS10445 pub unsafe fn RpcBindingSetObject(binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS {
10446     #[cfg(windows)]
10447     {
10448         #[link(name = "windows")]
10449         extern "system" {
10450             fn RpcBindingSetObject(binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS;
10451         }
10452         ::std::mem::transmute(RpcBindingSetObject(::std::mem::transmute(binding), ::std::mem::transmute(objectuuid)))
10453     }
10454     #[cfg(not(windows))]
10455     unimplemented!("Unsupported target OS");
10456 }
10457 #[inline]
RpcBindingSetOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS10458 pub unsafe fn RpcBindingSetOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS {
10459     #[cfg(windows)]
10460     {
10461         #[link(name = "windows")]
10462         extern "system" {
10463             fn RpcBindingSetOption(hbinding: *const ::std::ffi::c_void, option: u32, optionvalue: usize) -> RPC_STATUS;
10464         }
10465         ::std::mem::transmute(RpcBindingSetOption(::std::mem::transmute(hbinding), ::std::mem::transmute(option), ::std::mem::transmute(optionvalue)))
10466     }
10467     #[cfg(not(windows))]
10468     unimplemented!("Unsupported target OS");
10469 }
10470 #[inline]
RpcBindingToStringBindingA(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u8) -> RPC_STATUS10471 pub unsafe fn RpcBindingToStringBindingA(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u8) -> RPC_STATUS {
10472     #[cfg(windows)]
10473     {
10474         #[link(name = "windows")]
10475         extern "system" {
10476             fn RpcBindingToStringBindingA(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u8) -> RPC_STATUS;
10477         }
10478         ::std::mem::transmute(RpcBindingToStringBindingA(::std::mem::transmute(binding), ::std::mem::transmute(stringbinding)))
10479     }
10480     #[cfg(not(windows))]
10481     unimplemented!("Unsupported target OS");
10482 }
10483 #[inline]
RpcBindingToStringBindingW(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS10484 pub unsafe fn RpcBindingToStringBindingW(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS {
10485     #[cfg(windows)]
10486     {
10487         #[link(name = "windows")]
10488         extern "system" {
10489             fn RpcBindingToStringBindingW(binding: *const ::std::ffi::c_void, stringbinding: *mut *mut u16) -> RPC_STATUS;
10490         }
10491         ::std::mem::transmute(RpcBindingToStringBindingW(::std::mem::transmute(binding), ::std::mem::transmute(stringbinding)))
10492     }
10493     #[cfg(not(windows))]
10494     unimplemented!("Unsupported target OS");
10495 }
10496 #[inline]
RpcBindingUnbind(binding: *const ::std::ffi::c_void) -> RPC_STATUS10497 pub unsafe fn RpcBindingUnbind(binding: *const ::std::ffi::c_void) -> RPC_STATUS {
10498     #[cfg(windows)]
10499     {
10500         #[link(name = "windows")]
10501         extern "system" {
10502             fn RpcBindingUnbind(binding: *const ::std::ffi::c_void) -> RPC_STATUS;
10503         }
10504         ::std::mem::transmute(RpcBindingUnbind(::std::mem::transmute(binding)))
10505     }
10506     #[cfg(not(windows))]
10507     unimplemented!("Unsupported target OS");
10508 }
10509 #[inline]
RpcBindingVectorFree(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS10510 pub unsafe fn RpcBindingVectorFree(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS {
10511     #[cfg(windows)]
10512     {
10513         #[link(name = "windows")]
10514         extern "system" {
10515             fn RpcBindingVectorFree(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS;
10516         }
10517         ::std::mem::transmute(RpcBindingVectorFree(::std::mem::transmute(bindingvector)))
10518     }
10519     #[cfg(not(windows))]
10520     unimplemented!("Unsupported target OS");
10521 }
10522 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10523 #[repr(transparent)]
10524 pub struct RpcCallClientLocality(pub i32);
10525 pub const rcclInvalid: RpcCallClientLocality = RpcCallClientLocality(0i32);
10526 pub const rcclLocal: RpcCallClientLocality = RpcCallClientLocality(1i32);
10527 pub const rcclRemote: RpcCallClientLocality = RpcCallClientLocality(2i32);
10528 pub const rcclClientUnknownLocality: RpcCallClientLocality = RpcCallClientLocality(3i32);
10529 impl ::std::convert::From<i32> for RpcCallClientLocality {
from(value: i32) -> Self10530     fn from(value: i32) -> Self {
10531         Self(value)
10532     }
10533 }
10534 unsafe impl ::windows::runtime::Abi for RpcCallClientLocality {
10535     type Abi = Self;
10536     type DefaultType = Self;
10537 }
10538 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10539 #[repr(transparent)]
10540 pub struct RpcCallType(pub i32);
10541 pub const rctInvalid: RpcCallType = RpcCallType(0i32);
10542 pub const rctNormal: RpcCallType = RpcCallType(1i32);
10543 pub const rctTraining: RpcCallType = RpcCallType(2i32);
10544 pub const rctGuaranteed: RpcCallType = RpcCallType(3i32);
10545 impl ::std::convert::From<i32> for RpcCallType {
from(value: i32) -> Self10546     fn from(value: i32) -> Self {
10547         Self(value)
10548     }
10549 }
10550 unsafe impl ::windows::runtime::Abi for RpcCallType {
10551     type Abi = Self;
10552     type DefaultType = Self;
10553 }
10554 #[inline]
RpcCancelThread(thread: *const ::std::ffi::c_void) -> RPC_STATUS10555 pub unsafe fn RpcCancelThread(thread: *const ::std::ffi::c_void) -> RPC_STATUS {
10556     #[cfg(windows)]
10557     {
10558         #[link(name = "windows")]
10559         extern "system" {
10560             fn RpcCancelThread(thread: *const ::std::ffi::c_void) -> RPC_STATUS;
10561         }
10562         ::std::mem::transmute(RpcCancelThread(::std::mem::transmute(thread)))
10563     }
10564     #[cfg(not(windows))]
10565     unimplemented!("Unsupported target OS");
10566 }
10567 #[inline]
RpcCancelThreadEx(thread: *const ::std::ffi::c_void, timeout: i32) -> RPC_STATUS10568 pub unsafe fn RpcCancelThreadEx(thread: *const ::std::ffi::c_void, timeout: i32) -> RPC_STATUS {
10569     #[cfg(windows)]
10570     {
10571         #[link(name = "windows")]
10572         extern "system" {
10573             fn RpcCancelThreadEx(thread: *const ::std::ffi::c_void, timeout: i32) -> RPC_STATUS;
10574         }
10575         ::std::mem::transmute(RpcCancelThreadEx(::std::mem::transmute(thread), ::std::mem::transmute(timeout)))
10576     }
10577     #[cfg(not(windows))]
10578     unimplemented!("Unsupported target OS");
10579 }
10580 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
10581 #[inline]
RpcCertGeneratePrincipalNameA(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u8) -> RPC_STATUS10582 pub unsafe fn RpcCertGeneratePrincipalNameA(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u8) -> RPC_STATUS {
10583     #[cfg(windows)]
10584     {
10585         #[link(name = "windows")]
10586         extern "system" {
10587             fn RpcCertGeneratePrincipalNameA(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u8) -> RPC_STATUS;
10588         }
10589         ::std::mem::transmute(RpcCertGeneratePrincipalNameA(::std::mem::transmute(context), ::std::mem::transmute(flags), ::std::mem::transmute(pbuffer)))
10590     }
10591     #[cfg(not(windows))]
10592     unimplemented!("Unsupported target OS");
10593 }
10594 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
10595 #[inline]
RpcCertGeneratePrincipalNameW(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u16) -> RPC_STATUS10596 pub unsafe fn RpcCertGeneratePrincipalNameW(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u16) -> RPC_STATUS {
10597     #[cfg(windows)]
10598     {
10599         #[link(name = "windows")]
10600         extern "system" {
10601             fn RpcCertGeneratePrincipalNameW(context: *const super::super::Security::Cryptography::CERT_CONTEXT, flags: u32, pbuffer: *mut *mut u16) -> RPC_STATUS;
10602         }
10603         ::std::mem::transmute(RpcCertGeneratePrincipalNameW(::std::mem::transmute(context), ::std::mem::transmute(flags), ::std::mem::transmute(pbuffer)))
10604     }
10605     #[cfg(not(windows))]
10606     unimplemented!("Unsupported target OS");
10607 }
10608 #[inline]
RpcEpRegisterA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS10609 pub unsafe fn RpcEpRegisterA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS {
10610     #[cfg(windows)]
10611     {
10612         #[link(name = "windows")]
10613         extern "system" {
10614             fn RpcEpRegisterA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS;
10615         }
10616         ::std::mem::transmute(RpcEpRegisterA(::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvector), ::std::mem::transmute(uuidvector), ::std::mem::transmute(annotation)))
10617     }
10618     #[cfg(not(windows))]
10619     unimplemented!("Unsupported target OS");
10620 }
10621 #[inline]
RpcEpRegisterNoReplaceA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS10622 pub unsafe fn RpcEpRegisterNoReplaceA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS {
10623     #[cfg(windows)]
10624     {
10625         #[link(name = "windows")]
10626         extern "system" {
10627             fn RpcEpRegisterNoReplaceA(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u8) -> RPC_STATUS;
10628         }
10629         ::std::mem::transmute(RpcEpRegisterNoReplaceA(::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvector), ::std::mem::transmute(uuidvector), ::std::mem::transmute(annotation)))
10630     }
10631     #[cfg(not(windows))]
10632     unimplemented!("Unsupported target OS");
10633 }
10634 #[inline]
RpcEpRegisterNoReplaceW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS10635 pub unsafe fn RpcEpRegisterNoReplaceW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS {
10636     #[cfg(windows)]
10637     {
10638         #[link(name = "windows")]
10639         extern "system" {
10640             fn RpcEpRegisterNoReplaceW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS;
10641         }
10642         ::std::mem::transmute(RpcEpRegisterNoReplaceW(::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvector), ::std::mem::transmute(uuidvector), ::std::mem::transmute(annotation)))
10643     }
10644     #[cfg(not(windows))]
10645     unimplemented!("Unsupported target OS");
10646 }
10647 #[inline]
RpcEpRegisterW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS10648 pub unsafe fn RpcEpRegisterW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS {
10649     #[cfg(windows)]
10650     {
10651         #[link(name = "windows")]
10652         extern "system" {
10653             fn RpcEpRegisterW(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR, annotation: *const u16) -> RPC_STATUS;
10654         }
10655         ::std::mem::transmute(RpcEpRegisterW(::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvector), ::std::mem::transmute(uuidvector), ::std::mem::transmute(annotation)))
10656     }
10657     #[cfg(not(windows))]
10658     unimplemented!("Unsupported target OS");
10659 }
10660 #[inline]
RpcEpResolveBinding(binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS10661 pub unsafe fn RpcEpResolveBinding(binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS {
10662     #[cfg(windows)]
10663     {
10664         #[link(name = "windows")]
10665         extern "system" {
10666             fn RpcEpResolveBinding(binding: *const ::std::ffi::c_void, ifspec: *const ::std::ffi::c_void) -> RPC_STATUS;
10667         }
10668         ::std::mem::transmute(RpcEpResolveBinding(::std::mem::transmute(binding), ::std::mem::transmute(ifspec)))
10669     }
10670     #[cfg(not(windows))]
10671     unimplemented!("Unsupported target OS");
10672 }
10673 #[inline]
RpcEpUnregister(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR) -> RPC_STATUS10674 pub unsafe fn RpcEpUnregister(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR) -> RPC_STATUS {
10675     #[cfg(windows)]
10676     {
10677         #[link(name = "windows")]
10678         extern "system" {
10679             fn RpcEpUnregister(ifspec: *const ::std::ffi::c_void, bindingvector: *const RPC_BINDING_VECTOR, uuidvector: *const UUID_VECTOR) -> RPC_STATUS;
10680         }
10681         ::std::mem::transmute(RpcEpUnregister(::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvector), ::std::mem::transmute(uuidvector)))
10682     }
10683     #[cfg(not(windows))]
10684     unimplemented!("Unsupported target OS");
10685 }
10686 #[cfg(feature = "Win32_Foundation")]
10687 #[inline]
RpcErrorAddRecord(errorinfo: *const RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS10688 pub unsafe fn RpcErrorAddRecord(errorinfo: *const RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS {
10689     #[cfg(windows)]
10690     {
10691         #[link(name = "windows")]
10692         extern "system" {
10693             fn RpcErrorAddRecord(errorinfo: *const RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS;
10694         }
10695         ::std::mem::transmute(RpcErrorAddRecord(::std::mem::transmute(errorinfo)))
10696     }
10697     #[cfg(not(windows))]
10698     unimplemented!("Unsupported target OS");
10699 }
10700 #[inline]
RpcErrorClearInformation()10701 pub unsafe fn RpcErrorClearInformation() {
10702     #[cfg(windows)]
10703     {
10704         #[link(name = "windows")]
10705         extern "system" {
10706             fn RpcErrorClearInformation();
10707         }
10708         ::std::mem::transmute(RpcErrorClearInformation())
10709     }
10710     #[cfg(not(windows))]
10711     unimplemented!("Unsupported target OS");
10712 }
10713 #[inline]
RpcErrorEndEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS10714 pub unsafe fn RpcErrorEndEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS {
10715     #[cfg(windows)]
10716     {
10717         #[link(name = "windows")]
10718         extern "system" {
10719             fn RpcErrorEndEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS;
10720         }
10721         ::std::mem::transmute(RpcErrorEndEnumeration(::std::mem::transmute(enumhandle)))
10722     }
10723     #[cfg(not(windows))]
10724     unimplemented!("Unsupported target OS");
10725 }
10726 #[cfg(feature = "Win32_Foundation")]
10727 #[inline]
RpcErrorGetNextRecord<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(enumhandle: *const RPC_ERROR_ENUM_HANDLE, copystrings: Param1, errorinfo: *mut RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS10728 pub unsafe fn RpcErrorGetNextRecord<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(enumhandle: *const RPC_ERROR_ENUM_HANDLE, copystrings: Param1, errorinfo: *mut RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS {
10729     #[cfg(windows)]
10730     {
10731         #[link(name = "windows")]
10732         extern "system" {
10733             fn RpcErrorGetNextRecord(enumhandle: *const RPC_ERROR_ENUM_HANDLE, copystrings: super::super::Foundation::BOOL, errorinfo: *mut RPC_EXTENDED_ERROR_INFO) -> RPC_STATUS;
10734         }
10735         ::std::mem::transmute(RpcErrorGetNextRecord(::std::mem::transmute(enumhandle), copystrings.into_param().abi(), ::std::mem::transmute(errorinfo)))
10736     }
10737     #[cfg(not(windows))]
10738     unimplemented!("Unsupported target OS");
10739 }
10740 #[inline]
RpcErrorGetNumberOfRecords(enumhandle: *const RPC_ERROR_ENUM_HANDLE, records: *mut i32) -> RPC_STATUS10741 pub unsafe fn RpcErrorGetNumberOfRecords(enumhandle: *const RPC_ERROR_ENUM_HANDLE, records: *mut i32) -> RPC_STATUS {
10742     #[cfg(windows)]
10743     {
10744         #[link(name = "windows")]
10745         extern "system" {
10746             fn RpcErrorGetNumberOfRecords(enumhandle: *const RPC_ERROR_ENUM_HANDLE, records: *mut i32) -> RPC_STATUS;
10747         }
10748         ::std::mem::transmute(RpcErrorGetNumberOfRecords(::std::mem::transmute(enumhandle), ::std::mem::transmute(records)))
10749     }
10750     #[cfg(not(windows))]
10751     unimplemented!("Unsupported target OS");
10752 }
10753 #[inline]
RpcErrorLoadErrorInfo(errorblob: *const ::std::ffi::c_void, blobsize: usize, enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS10754 pub unsafe fn RpcErrorLoadErrorInfo(errorblob: *const ::std::ffi::c_void, blobsize: usize, enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS {
10755     #[cfg(windows)]
10756     {
10757         #[link(name = "windows")]
10758         extern "system" {
10759             fn RpcErrorLoadErrorInfo(errorblob: *const ::std::ffi::c_void, blobsize: usize, enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS;
10760         }
10761         ::std::mem::transmute(RpcErrorLoadErrorInfo(::std::mem::transmute(errorblob), ::std::mem::transmute(blobsize), ::std::mem::transmute(enumhandle)))
10762     }
10763     #[cfg(not(windows))]
10764     unimplemented!("Unsupported target OS");
10765 }
10766 #[inline]
RpcErrorResetEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS10767 pub unsafe fn RpcErrorResetEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS {
10768     #[cfg(windows)]
10769     {
10770         #[link(name = "windows")]
10771         extern "system" {
10772             fn RpcErrorResetEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS;
10773         }
10774         ::std::mem::transmute(RpcErrorResetEnumeration(::std::mem::transmute(enumhandle)))
10775     }
10776     #[cfg(not(windows))]
10777     unimplemented!("Unsupported target OS");
10778 }
10779 #[inline]
RpcErrorSaveErrorInfo(enumhandle: *const RPC_ERROR_ENUM_HANDLE, errorblob: *mut *mut ::std::ffi::c_void, blobsize: *mut usize) -> RPC_STATUS10780 pub unsafe fn RpcErrorSaveErrorInfo(enumhandle: *const RPC_ERROR_ENUM_HANDLE, errorblob: *mut *mut ::std::ffi::c_void, blobsize: *mut usize) -> RPC_STATUS {
10781     #[cfg(windows)]
10782     {
10783         #[link(name = "windows")]
10784         extern "system" {
10785             fn RpcErrorSaveErrorInfo(enumhandle: *const RPC_ERROR_ENUM_HANDLE, errorblob: *mut *mut ::std::ffi::c_void, blobsize: *mut usize) -> RPC_STATUS;
10786         }
10787         ::std::mem::transmute(RpcErrorSaveErrorInfo(::std::mem::transmute(enumhandle), ::std::mem::transmute(errorblob), ::std::mem::transmute(blobsize)))
10788     }
10789     #[cfg(not(windows))]
10790     unimplemented!("Unsupported target OS");
10791 }
10792 #[inline]
RpcErrorStartEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS10793 pub unsafe fn RpcErrorStartEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS {
10794     #[cfg(windows)]
10795     {
10796         #[link(name = "windows")]
10797         extern "system" {
10798             fn RpcErrorStartEnumeration(enumhandle: *mut RPC_ERROR_ENUM_HANDLE) -> RPC_STATUS;
10799         }
10800         ::std::mem::transmute(RpcErrorStartEnumeration(::std::mem::transmute(enumhandle)))
10801     }
10802     #[cfg(not(windows))]
10803     unimplemented!("Unsupported target OS");
10804 }
10805 #[inline]
RpcExceptionFilter(exceptioncode: u32) -> i3210806 pub unsafe fn RpcExceptionFilter(exceptioncode: u32) -> i32 {
10807     #[cfg(windows)]
10808     {
10809         #[link(name = "windows")]
10810         extern "system" {
10811             fn RpcExceptionFilter(exceptioncode: u32) -> i32;
10812         }
10813         ::std::mem::transmute(RpcExceptionFilter(::std::mem::transmute(exceptioncode)))
10814     }
10815     #[cfg(not(windows))]
10816     unimplemented!("Unsupported target OS");
10817 }
10818 #[inline]
RpcFreeAuthorizationContext(pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10819 pub unsafe fn RpcFreeAuthorizationContext(pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10820     #[cfg(windows)]
10821     {
10822         #[link(name = "windows")]
10823         extern "system" {
10824             fn RpcFreeAuthorizationContext(pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10825         }
10826         ::std::mem::transmute(RpcFreeAuthorizationContext(::std::mem::transmute(pauthzclientcontext)))
10827     }
10828     #[cfg(not(windows))]
10829     unimplemented!("Unsupported target OS");
10830 }
10831 #[cfg(feature = "Win32_Foundation")]
10832 #[inline]
RpcGetAuthorizationContextForClient<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(clientbinding: *const ::std::ffi::c_void, impersonateonreturn: Param1, reserved1: *const ::std::ffi::c_void, pexpirationtime: *const i64, reserved2: Param4, reserved3: u32, reserved4: *const ::std::ffi::c_void, pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS10833 pub unsafe fn RpcGetAuthorizationContextForClient<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::LUID>>(clientbinding: *const ::std::ffi::c_void, impersonateonreturn: Param1, reserved1: *const ::std::ffi::c_void, pexpirationtime: *const i64, reserved2: Param4, reserved3: u32, reserved4: *const ::std::ffi::c_void, pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10834     #[cfg(windows)]
10835     {
10836         #[link(name = "windows")]
10837         extern "system" {
10838             fn RpcGetAuthorizationContextForClient(clientbinding: *const ::std::ffi::c_void, impersonateonreturn: super::super::Foundation::BOOL, reserved1: *const ::std::ffi::c_void, pexpirationtime: *const i64, reserved2: super::super::Foundation::LUID, reserved3: u32, reserved4: *const ::std::ffi::c_void, pauthzclientcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10839         }
10840         ::std::mem::transmute(RpcGetAuthorizationContextForClient(
10841             ::std::mem::transmute(clientbinding),
10842             impersonateonreturn.into_param().abi(),
10843             ::std::mem::transmute(reserved1),
10844             ::std::mem::transmute(pexpirationtime),
10845             reserved2.into_param().abi(),
10846             ::std::mem::transmute(reserved3),
10847             ::std::mem::transmute(reserved4),
10848             ::std::mem::transmute(pauthzclientcontext),
10849         ))
10850     }
10851     #[cfg(not(windows))]
10852     unimplemented!("Unsupported target OS");
10853 }
10854 #[inline]
RpcIfIdVectorFree(ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS10855 pub unsafe fn RpcIfIdVectorFree(ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS {
10856     #[cfg(windows)]
10857     {
10858         #[link(name = "windows")]
10859         extern "system" {
10860             fn RpcIfIdVectorFree(ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS;
10861         }
10862         ::std::mem::transmute(RpcIfIdVectorFree(::std::mem::transmute(ifidvector)))
10863     }
10864     #[cfg(not(windows))]
10865     unimplemented!("Unsupported target OS");
10866 }
10867 #[inline]
RpcIfInqId(rpcifhandle: *const ::std::ffi::c_void, rpcifid: *mut RPC_IF_ID) -> RPC_STATUS10868 pub unsafe fn RpcIfInqId(rpcifhandle: *const ::std::ffi::c_void, rpcifid: *mut RPC_IF_ID) -> RPC_STATUS {
10869     #[cfg(windows)]
10870     {
10871         #[link(name = "windows")]
10872         extern "system" {
10873             fn RpcIfInqId(rpcifhandle: *const ::std::ffi::c_void, rpcifid: *mut RPC_IF_ID) -> RPC_STATUS;
10874         }
10875         ::std::mem::transmute(RpcIfInqId(::std::mem::transmute(rpcifhandle), ::std::mem::transmute(rpcifid)))
10876     }
10877     #[cfg(not(windows))]
10878     unimplemented!("Unsupported target OS");
10879 }
10880 #[inline]
RpcImpersonateClient(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS10881 pub unsafe fn RpcImpersonateClient(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS {
10882     #[cfg(windows)]
10883     {
10884         #[link(name = "windows")]
10885         extern "system" {
10886             fn RpcImpersonateClient(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS;
10887         }
10888         ::std::mem::transmute(RpcImpersonateClient(::std::mem::transmute(bindinghandle)))
10889     }
10890     #[cfg(not(windows))]
10891     unimplemented!("Unsupported target OS");
10892 }
10893 #[inline]
RpcImpersonateClient2(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS10894 pub unsafe fn RpcImpersonateClient2(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS {
10895     #[cfg(windows)]
10896     {
10897         #[link(name = "windows")]
10898         extern "system" {
10899             fn RpcImpersonateClient2(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS;
10900         }
10901         ::std::mem::transmute(RpcImpersonateClient2(::std::mem::transmute(bindinghandle)))
10902     }
10903     #[cfg(not(windows))]
10904     unimplemented!("Unsupported target OS");
10905 }
10906 #[inline]
RpcImpersonateClientContainer(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS10907 pub unsafe fn RpcImpersonateClientContainer(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS {
10908     #[cfg(windows)]
10909     {
10910         #[link(name = "windows")]
10911         extern "system" {
10912             fn RpcImpersonateClientContainer(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS;
10913         }
10914         ::std::mem::transmute(RpcImpersonateClientContainer(::std::mem::transmute(bindinghandle)))
10915     }
10916     #[cfg(not(windows))]
10917     unimplemented!("Unsupported target OS");
10918 }
10919 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10920 #[repr(transparent)]
10921 pub struct RpcLocalAddressFormat(pub i32);
10922 pub const rlafInvalid: RpcLocalAddressFormat = RpcLocalAddressFormat(0i32);
10923 pub const rlafIPv4: RpcLocalAddressFormat = RpcLocalAddressFormat(1i32);
10924 pub const rlafIPv6: RpcLocalAddressFormat = RpcLocalAddressFormat(2i32);
10925 impl ::std::convert::From<i32> for RpcLocalAddressFormat {
from(value: i32) -> Self10926     fn from(value: i32) -> Self {
10927         Self(value)
10928     }
10929 }
10930 unsafe impl ::windows::runtime::Abi for RpcLocalAddressFormat {
10931     type Abi = Self;
10932     type DefaultType = Self;
10933 }
10934 #[inline]
RpcMgmtEnableIdleCleanup() -> RPC_STATUS10935 pub unsafe fn RpcMgmtEnableIdleCleanup() -> RPC_STATUS {
10936     #[cfg(windows)]
10937     {
10938         #[link(name = "windows")]
10939         extern "system" {
10940             fn RpcMgmtEnableIdleCleanup() -> RPC_STATUS;
10941         }
10942         ::std::mem::transmute(RpcMgmtEnableIdleCleanup())
10943     }
10944     #[cfg(not(windows))]
10945     unimplemented!("Unsupported target OS");
10946 }
10947 #[inline]
RpcMgmtEpEltInqBegin(epbinding: *const ::std::ffi::c_void, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, objectuuid: *const ::windows::runtime::GUID, inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS10948 pub unsafe fn RpcMgmtEpEltInqBegin(epbinding: *const ::std::ffi::c_void, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, objectuuid: *const ::windows::runtime::GUID, inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10949     #[cfg(windows)]
10950     {
10951         #[link(name = "windows")]
10952         extern "system" {
10953             fn RpcMgmtEpEltInqBegin(epbinding: *const ::std::ffi::c_void, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, objectuuid: *const ::windows::runtime::GUID, inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10954         }
10955         ::std::mem::transmute(RpcMgmtEpEltInqBegin(::std::mem::transmute(epbinding), ::std::mem::transmute(inquirytype), ::std::mem::transmute(ifid), ::std::mem::transmute(versoption), ::std::mem::transmute(objectuuid), ::std::mem::transmute(inquirycontext)))
10956     }
10957     #[cfg(not(windows))]
10958     unimplemented!("Unsupported target OS");
10959 }
10960 #[inline]
RpcMgmtEpEltInqDone(inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS10961 pub unsafe fn RpcMgmtEpEltInqDone(inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
10962     #[cfg(windows)]
10963     {
10964         #[link(name = "windows")]
10965         extern "system" {
10966             fn RpcMgmtEpEltInqDone(inquirycontext: *mut *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
10967         }
10968         ::std::mem::transmute(RpcMgmtEpEltInqDone(::std::mem::transmute(inquirycontext)))
10969     }
10970     #[cfg(not(windows))]
10971     unimplemented!("Unsupported target OS");
10972 }
10973 #[inline]
RpcMgmtEpEltInqNextA(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u8) -> RPC_STATUS10974 pub unsafe fn RpcMgmtEpEltInqNextA(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u8) -> RPC_STATUS {
10975     #[cfg(windows)]
10976     {
10977         #[link(name = "windows")]
10978         extern "system" {
10979             fn RpcMgmtEpEltInqNextA(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u8) -> RPC_STATUS;
10980         }
10981         ::std::mem::transmute(RpcMgmtEpEltInqNextA(::std::mem::transmute(inquirycontext), ::std::mem::transmute(ifid), ::std::mem::transmute(binding), ::std::mem::transmute(objectuuid), ::std::mem::transmute(annotation)))
10982     }
10983     #[cfg(not(windows))]
10984     unimplemented!("Unsupported target OS");
10985 }
10986 #[inline]
RpcMgmtEpEltInqNextW(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u16) -> RPC_STATUS10987 pub unsafe fn RpcMgmtEpEltInqNextW(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u16) -> RPC_STATUS {
10988     #[cfg(windows)]
10989     {
10990         #[link(name = "windows")]
10991         extern "system" {
10992             fn RpcMgmtEpEltInqNextW(inquirycontext: *const *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, binding: *mut *mut ::std::ffi::c_void, objectuuid: *mut ::windows::runtime::GUID, annotation: *mut *mut u16) -> RPC_STATUS;
10993         }
10994         ::std::mem::transmute(RpcMgmtEpEltInqNextW(::std::mem::transmute(inquirycontext), ::std::mem::transmute(ifid), ::std::mem::transmute(binding), ::std::mem::transmute(objectuuid), ::std::mem::transmute(annotation)))
10995     }
10996     #[cfg(not(windows))]
10997     unimplemented!("Unsupported target OS");
10998 }
10999 #[inline]
RpcMgmtEpUnregister(epbinding: *const ::std::ffi::c_void, ifid: *const RPC_IF_ID, binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS11000 pub unsafe fn RpcMgmtEpUnregister(epbinding: *const ::std::ffi::c_void, ifid: *const RPC_IF_ID, binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS {
11001     #[cfg(windows)]
11002     {
11003         #[link(name = "windows")]
11004         extern "system" {
11005             fn RpcMgmtEpUnregister(epbinding: *const ::std::ffi::c_void, ifid: *const RPC_IF_ID, binding: *const ::std::ffi::c_void, objectuuid: *const ::windows::runtime::GUID) -> RPC_STATUS;
11006         }
11007         ::std::mem::transmute(RpcMgmtEpUnregister(::std::mem::transmute(epbinding), ::std::mem::transmute(ifid), ::std::mem::transmute(binding), ::std::mem::transmute(objectuuid)))
11008     }
11009     #[cfg(not(windows))]
11010     unimplemented!("Unsupported target OS");
11011 }
11012 #[inline]
RpcMgmtInqComTimeout(binding: *const ::std::ffi::c_void, timeout: *mut u32) -> RPC_STATUS11013 pub unsafe fn RpcMgmtInqComTimeout(binding: *const ::std::ffi::c_void, timeout: *mut u32) -> RPC_STATUS {
11014     #[cfg(windows)]
11015     {
11016         #[link(name = "windows")]
11017         extern "system" {
11018             fn RpcMgmtInqComTimeout(binding: *const ::std::ffi::c_void, timeout: *mut u32) -> RPC_STATUS;
11019         }
11020         ::std::mem::transmute(RpcMgmtInqComTimeout(::std::mem::transmute(binding), ::std::mem::transmute(timeout)))
11021     }
11022     #[cfg(not(windows))]
11023     unimplemented!("Unsupported target OS");
11024 }
11025 #[inline]
RpcMgmtInqDefaultProtectLevel(authnsvc: u32, authnlevel: *mut u32) -> RPC_STATUS11026 pub unsafe fn RpcMgmtInqDefaultProtectLevel(authnsvc: u32, authnlevel: *mut u32) -> RPC_STATUS {
11027     #[cfg(windows)]
11028     {
11029         #[link(name = "windows")]
11030         extern "system" {
11031             fn RpcMgmtInqDefaultProtectLevel(authnsvc: u32, authnlevel: *mut u32) -> RPC_STATUS;
11032         }
11033         ::std::mem::transmute(RpcMgmtInqDefaultProtectLevel(::std::mem::transmute(authnsvc), ::std::mem::transmute(authnlevel)))
11034     }
11035     #[cfg(not(windows))]
11036     unimplemented!("Unsupported target OS");
11037 }
11038 #[inline]
RpcMgmtInqIfIds(binding: *const ::std::ffi::c_void, ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS11039 pub unsafe fn RpcMgmtInqIfIds(binding: *const ::std::ffi::c_void, ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS {
11040     #[cfg(windows)]
11041     {
11042         #[link(name = "windows")]
11043         extern "system" {
11044             fn RpcMgmtInqIfIds(binding: *const ::std::ffi::c_void, ifidvector: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS;
11045         }
11046         ::std::mem::transmute(RpcMgmtInqIfIds(::std::mem::transmute(binding), ::std::mem::transmute(ifidvector)))
11047     }
11048     #[cfg(not(windows))]
11049     unimplemented!("Unsupported target OS");
11050 }
11051 #[inline]
RpcMgmtInqServerPrincNameA(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u8) -> RPC_STATUS11052 pub unsafe fn RpcMgmtInqServerPrincNameA(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u8) -> RPC_STATUS {
11053     #[cfg(windows)]
11054     {
11055         #[link(name = "windows")]
11056         extern "system" {
11057             fn RpcMgmtInqServerPrincNameA(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u8) -> RPC_STATUS;
11058         }
11059         ::std::mem::transmute(RpcMgmtInqServerPrincNameA(::std::mem::transmute(binding), ::std::mem::transmute(authnsvc), ::std::mem::transmute(serverprincname)))
11060     }
11061     #[cfg(not(windows))]
11062     unimplemented!("Unsupported target OS");
11063 }
11064 #[inline]
RpcMgmtInqServerPrincNameW(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u16) -> RPC_STATUS11065 pub unsafe fn RpcMgmtInqServerPrincNameW(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u16) -> RPC_STATUS {
11066     #[cfg(windows)]
11067     {
11068         #[link(name = "windows")]
11069         extern "system" {
11070             fn RpcMgmtInqServerPrincNameW(binding: *const ::std::ffi::c_void, authnsvc: u32, serverprincname: *mut *mut u16) -> RPC_STATUS;
11071         }
11072         ::std::mem::transmute(RpcMgmtInqServerPrincNameW(::std::mem::transmute(binding), ::std::mem::transmute(authnsvc), ::std::mem::transmute(serverprincname)))
11073     }
11074     #[cfg(not(windows))]
11075     unimplemented!("Unsupported target OS");
11076 }
11077 #[inline]
RpcMgmtInqStats(binding: *const ::std::ffi::c_void, statistics: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS11078 pub unsafe fn RpcMgmtInqStats(binding: *const ::std::ffi::c_void, statistics: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS {
11079     #[cfg(windows)]
11080     {
11081         #[link(name = "windows")]
11082         extern "system" {
11083             fn RpcMgmtInqStats(binding: *const ::std::ffi::c_void, statistics: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS;
11084         }
11085         ::std::mem::transmute(RpcMgmtInqStats(::std::mem::transmute(binding), ::std::mem::transmute(statistics)))
11086     }
11087     #[cfg(not(windows))]
11088     unimplemented!("Unsupported target OS");
11089 }
11090 #[inline]
RpcMgmtIsServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS11091 pub unsafe fn RpcMgmtIsServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS {
11092     #[cfg(windows)]
11093     {
11094         #[link(name = "windows")]
11095         extern "system" {
11096             fn RpcMgmtIsServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS;
11097         }
11098         ::std::mem::transmute(RpcMgmtIsServerListening(::std::mem::transmute(binding)))
11099     }
11100     #[cfg(not(windows))]
11101     unimplemented!("Unsupported target OS");
11102 }
11103 #[inline]
RpcMgmtSetAuthorizationFn(authorizationfn: ::std::option::Option<RPC_MGMT_AUTHORIZATION_FN>) -> RPC_STATUS11104 pub unsafe fn RpcMgmtSetAuthorizationFn(authorizationfn: ::std::option::Option<RPC_MGMT_AUTHORIZATION_FN>) -> RPC_STATUS {
11105     #[cfg(windows)]
11106     {
11107         #[link(name = "windows")]
11108         extern "system" {
11109             fn RpcMgmtSetAuthorizationFn(authorizationfn: ::windows::runtime::RawPtr) -> RPC_STATUS;
11110         }
11111         ::std::mem::transmute(RpcMgmtSetAuthorizationFn(::std::mem::transmute(authorizationfn)))
11112     }
11113     #[cfg(not(windows))]
11114     unimplemented!("Unsupported target OS");
11115 }
11116 #[inline]
RpcMgmtSetCancelTimeout(timeout: i32) -> RPC_STATUS11117 pub unsafe fn RpcMgmtSetCancelTimeout(timeout: i32) -> RPC_STATUS {
11118     #[cfg(windows)]
11119     {
11120         #[link(name = "windows")]
11121         extern "system" {
11122             fn RpcMgmtSetCancelTimeout(timeout: i32) -> RPC_STATUS;
11123         }
11124         ::std::mem::transmute(RpcMgmtSetCancelTimeout(::std::mem::transmute(timeout)))
11125     }
11126     #[cfg(not(windows))]
11127     unimplemented!("Unsupported target OS");
11128 }
11129 #[inline]
RpcMgmtSetComTimeout(binding: *const ::std::ffi::c_void, timeout: u32) -> RPC_STATUS11130 pub unsafe fn RpcMgmtSetComTimeout(binding: *const ::std::ffi::c_void, timeout: u32) -> RPC_STATUS {
11131     #[cfg(windows)]
11132     {
11133         #[link(name = "windows")]
11134         extern "system" {
11135             fn RpcMgmtSetComTimeout(binding: *const ::std::ffi::c_void, timeout: u32) -> RPC_STATUS;
11136         }
11137         ::std::mem::transmute(RpcMgmtSetComTimeout(::std::mem::transmute(binding), ::std::mem::transmute(timeout)))
11138     }
11139     #[cfg(not(windows))]
11140     unimplemented!("Unsupported target OS");
11141 }
11142 #[inline]
RpcMgmtSetServerStackSize(threadstacksize: u32) -> RPC_STATUS11143 pub unsafe fn RpcMgmtSetServerStackSize(threadstacksize: u32) -> RPC_STATUS {
11144     #[cfg(windows)]
11145     {
11146         #[link(name = "windows")]
11147         extern "system" {
11148             fn RpcMgmtSetServerStackSize(threadstacksize: u32) -> RPC_STATUS;
11149         }
11150         ::std::mem::transmute(RpcMgmtSetServerStackSize(::std::mem::transmute(threadstacksize)))
11151     }
11152     #[cfg(not(windows))]
11153     unimplemented!("Unsupported target OS");
11154 }
11155 #[inline]
RpcMgmtStatsVectorFree(statsvector: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS11156 pub unsafe fn RpcMgmtStatsVectorFree(statsvector: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS {
11157     #[cfg(windows)]
11158     {
11159         #[link(name = "windows")]
11160         extern "system" {
11161             fn RpcMgmtStatsVectorFree(statsvector: *mut *mut RPC_STATS_VECTOR) -> RPC_STATUS;
11162         }
11163         ::std::mem::transmute(RpcMgmtStatsVectorFree(::std::mem::transmute(statsvector)))
11164     }
11165     #[cfg(not(windows))]
11166     unimplemented!("Unsupported target OS");
11167 }
11168 #[inline]
RpcMgmtStopServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS11169 pub unsafe fn RpcMgmtStopServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS {
11170     #[cfg(windows)]
11171     {
11172         #[link(name = "windows")]
11173         extern "system" {
11174             fn RpcMgmtStopServerListening(binding: *const ::std::ffi::c_void) -> RPC_STATUS;
11175         }
11176         ::std::mem::transmute(RpcMgmtStopServerListening(::std::mem::transmute(binding)))
11177     }
11178     #[cfg(not(windows))]
11179     unimplemented!("Unsupported target OS");
11180 }
11181 #[inline]
RpcMgmtWaitServerListen() -> RPC_STATUS11182 pub unsafe fn RpcMgmtWaitServerListen() -> RPC_STATUS {
11183     #[cfg(windows)]
11184     {
11185         #[link(name = "windows")]
11186         extern "system" {
11187             fn RpcMgmtWaitServerListen() -> RPC_STATUS;
11188         }
11189         ::std::mem::transmute(RpcMgmtWaitServerListen())
11190     }
11191     #[cfg(not(windows))]
11192     unimplemented!("Unsupported target OS");
11193 }
11194 #[inline]
RpcNetworkInqProtseqsA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS11195 pub unsafe fn RpcNetworkInqProtseqsA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS {
11196     #[cfg(windows)]
11197     {
11198         #[link(name = "windows")]
11199         extern "system" {
11200             fn RpcNetworkInqProtseqsA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS;
11201         }
11202         ::std::mem::transmute(RpcNetworkInqProtseqsA(::std::mem::transmute(protseqvector)))
11203     }
11204     #[cfg(not(windows))]
11205     unimplemented!("Unsupported target OS");
11206 }
11207 #[inline]
RpcNetworkInqProtseqsW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS11208 pub unsafe fn RpcNetworkInqProtseqsW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS {
11209     #[cfg(windows)]
11210     {
11211         #[link(name = "windows")]
11212         extern "system" {
11213             fn RpcNetworkInqProtseqsW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS;
11214         }
11215         ::std::mem::transmute(RpcNetworkInqProtseqsW(::std::mem::transmute(protseqvector)))
11216     }
11217     #[cfg(not(windows))]
11218     unimplemented!("Unsupported target OS");
11219 }
11220 #[inline]
RpcNetworkIsProtseqValidA(protseq: *const u8) -> RPC_STATUS11221 pub unsafe fn RpcNetworkIsProtseqValidA(protseq: *const u8) -> RPC_STATUS {
11222     #[cfg(windows)]
11223     {
11224         #[link(name = "windows")]
11225         extern "system" {
11226             fn RpcNetworkIsProtseqValidA(protseq: *const u8) -> RPC_STATUS;
11227         }
11228         ::std::mem::transmute(RpcNetworkIsProtseqValidA(::std::mem::transmute(protseq)))
11229     }
11230     #[cfg(not(windows))]
11231     unimplemented!("Unsupported target OS");
11232 }
11233 #[inline]
RpcNetworkIsProtseqValidW(protseq: *const u16) -> RPC_STATUS11234 pub unsafe fn RpcNetworkIsProtseqValidW(protseq: *const u16) -> RPC_STATUS {
11235     #[cfg(windows)]
11236     {
11237         #[link(name = "windows")]
11238         extern "system" {
11239             fn RpcNetworkIsProtseqValidW(protseq: *const u16) -> RPC_STATUS;
11240         }
11241         ::std::mem::transmute(RpcNetworkIsProtseqValidW(::std::mem::transmute(protseq)))
11242     }
11243     #[cfg(not(windows))]
11244     unimplemented!("Unsupported target OS");
11245 }
11246 #[inline]
RpcNsBindingExportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11247 pub unsafe fn RpcNsBindingExportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11248     #[cfg(windows)]
11249     {
11250         #[link(name = "windows")]
11251         extern "system" {
11252             fn RpcNsBindingExportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11253         }
11254         ::std::mem::transmute(RpcNsBindingExportA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvec), ::std::mem::transmute(objectuuidvec)))
11255     }
11256     #[cfg(not(windows))]
11257     unimplemented!("Unsupported target OS");
11258 }
11259 #[inline]
RpcNsBindingExportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS11260 pub unsafe fn RpcNsBindingExportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS {
11261     #[cfg(windows)]
11262     {
11263         #[link(name = "windows")]
11264         extern "system" {
11265             fn RpcNsBindingExportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS;
11266         }
11267         ::std::mem::transmute(RpcNsBindingExportPnPA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectvector)))
11268     }
11269     #[cfg(not(windows))]
11270     unimplemented!("Unsupported target OS");
11271 }
11272 #[inline]
RpcNsBindingExportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS11273 pub unsafe fn RpcNsBindingExportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS {
11274     #[cfg(windows)]
11275     {
11276         #[link(name = "windows")]
11277         extern "system" {
11278             fn RpcNsBindingExportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS;
11279         }
11280         ::std::mem::transmute(RpcNsBindingExportPnPW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectvector)))
11281     }
11282     #[cfg(not(windows))]
11283     unimplemented!("Unsupported target OS");
11284 }
11285 #[inline]
RpcNsBindingExportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11286 pub unsafe fn RpcNsBindingExportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11287     #[cfg(windows)]
11288     {
11289         #[link(name = "windows")]
11290         extern "system" {
11291             fn RpcNsBindingExportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, bindingvec: *const RPC_BINDING_VECTOR, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11292         }
11293         ::std::mem::transmute(RpcNsBindingExportW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(bindingvec), ::std::mem::transmute(objectuuidvec)))
11294     }
11295     #[cfg(not(windows))]
11296     unimplemented!("Unsupported target OS");
11297 }
11298 #[inline]
RpcNsBindingImportBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11299 pub unsafe fn RpcNsBindingImportBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11300     #[cfg(windows)]
11301     {
11302         #[link(name = "windows")]
11303         extern "system" {
11304             fn RpcNsBindingImportBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11305         }
11306         ::std::mem::transmute(RpcNsBindingImportBeginA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objuuid), ::std::mem::transmute(importcontext)))
11307     }
11308     #[cfg(not(windows))]
11309     unimplemented!("Unsupported target OS");
11310 }
11311 #[inline]
RpcNsBindingImportBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11312 pub unsafe fn RpcNsBindingImportBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11313     #[cfg(windows)]
11314     {
11315         #[link(name = "windows")]
11316         extern "system" {
11317             fn RpcNsBindingImportBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11318         }
11319         ::std::mem::transmute(RpcNsBindingImportBeginW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objuuid), ::std::mem::transmute(importcontext)))
11320     }
11321     #[cfg(not(windows))]
11322     unimplemented!("Unsupported target OS");
11323 }
11324 #[inline]
RpcNsBindingImportDone(importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11325 pub unsafe fn RpcNsBindingImportDone(importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11326     #[cfg(windows)]
11327     {
11328         #[link(name = "windows")]
11329         extern "system" {
11330             fn RpcNsBindingImportDone(importcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11331         }
11332         ::std::mem::transmute(RpcNsBindingImportDone(::std::mem::transmute(importcontext)))
11333     }
11334     #[cfg(not(windows))]
11335     unimplemented!("Unsupported target OS");
11336 }
11337 #[inline]
RpcNsBindingImportNext(importcontext: *mut ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11338 pub unsafe fn RpcNsBindingImportNext(importcontext: *mut ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11339     #[cfg(windows)]
11340     {
11341         #[link(name = "windows")]
11342         extern "system" {
11343             fn RpcNsBindingImportNext(importcontext: *mut ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11344         }
11345         ::std::mem::transmute(RpcNsBindingImportNext(::std::mem::transmute(importcontext), ::std::mem::transmute(binding)))
11346     }
11347     #[cfg(not(windows))]
11348     unimplemented!("Unsupported target OS");
11349 }
11350 #[inline]
RpcNsBindingInqEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u8) -> RPC_STATUS11351 pub unsafe fn RpcNsBindingInqEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u8) -> RPC_STATUS {
11352     #[cfg(windows)]
11353     {
11354         #[link(name = "windows")]
11355         extern "system" {
11356             fn RpcNsBindingInqEntryNameA(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u8) -> RPC_STATUS;
11357         }
11358         ::std::mem::transmute(RpcNsBindingInqEntryNameA(::std::mem::transmute(binding), ::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11359     }
11360     #[cfg(not(windows))]
11361     unimplemented!("Unsupported target OS");
11362 }
11363 #[inline]
RpcNsBindingInqEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u16) -> RPC_STATUS11364 pub unsafe fn RpcNsBindingInqEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u16) -> RPC_STATUS {
11365     #[cfg(windows)]
11366     {
11367         #[link(name = "windows")]
11368         extern "system" {
11369             fn RpcNsBindingInqEntryNameW(binding: *const ::std::ffi::c_void, entrynamesyntax: u32, entryname: *mut *mut u16) -> RPC_STATUS;
11370         }
11371         ::std::mem::transmute(RpcNsBindingInqEntryNameW(::std::mem::transmute(binding), ::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11372     }
11373     #[cfg(not(windows))]
11374     unimplemented!("Unsupported target OS");
11375 }
11376 #[inline]
RpcNsBindingLookupBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11377 pub unsafe fn RpcNsBindingLookupBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11378     #[cfg(windows)]
11379     {
11380         #[link(name = "windows")]
11381         extern "system" {
11382             fn RpcNsBindingLookupBeginA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11383         }
11384         ::std::mem::transmute(RpcNsBindingLookupBeginA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objuuid), ::std::mem::transmute(bindingmaxcount), ::std::mem::transmute(lookupcontext)))
11385     }
11386     #[cfg(not(windows))]
11387     unimplemented!("Unsupported target OS");
11388 }
11389 #[inline]
RpcNsBindingLookupBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11390 pub unsafe fn RpcNsBindingLookupBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11391     #[cfg(windows)]
11392     {
11393         #[link(name = "windows")]
11394         extern "system" {
11395             fn RpcNsBindingLookupBeginW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objuuid: *const ::windows::runtime::GUID, bindingmaxcount: u32, lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11396         }
11397         ::std::mem::transmute(RpcNsBindingLookupBeginW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objuuid), ::std::mem::transmute(bindingmaxcount), ::std::mem::transmute(lookupcontext)))
11398     }
11399     #[cfg(not(windows))]
11400     unimplemented!("Unsupported target OS");
11401 }
11402 #[inline]
RpcNsBindingLookupDone(lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11403 pub unsafe fn RpcNsBindingLookupDone(lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11404     #[cfg(windows)]
11405     {
11406         #[link(name = "windows")]
11407         extern "system" {
11408             fn RpcNsBindingLookupDone(lookupcontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11409         }
11410         ::std::mem::transmute(RpcNsBindingLookupDone(::std::mem::transmute(lookupcontext)))
11411     }
11412     #[cfg(not(windows))]
11413     unimplemented!("Unsupported target OS");
11414 }
11415 #[inline]
RpcNsBindingLookupNext(lookupcontext: *mut ::std::ffi::c_void, bindingvec: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS11416 pub unsafe fn RpcNsBindingLookupNext(lookupcontext: *mut ::std::ffi::c_void, bindingvec: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS {
11417     #[cfg(windows)]
11418     {
11419         #[link(name = "windows")]
11420         extern "system" {
11421             fn RpcNsBindingLookupNext(lookupcontext: *mut ::std::ffi::c_void, bindingvec: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS;
11422         }
11423         ::std::mem::transmute(RpcNsBindingLookupNext(::std::mem::transmute(lookupcontext), ::std::mem::transmute(bindingvec)))
11424     }
11425     #[cfg(not(windows))]
11426     unimplemented!("Unsupported target OS");
11427 }
11428 #[inline]
RpcNsBindingSelect(bindingvec: *mut RPC_BINDING_VECTOR, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11429 pub unsafe fn RpcNsBindingSelect(bindingvec: *mut RPC_BINDING_VECTOR, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11430     #[cfg(windows)]
11431     {
11432         #[link(name = "windows")]
11433         extern "system" {
11434             fn RpcNsBindingSelect(bindingvec: *mut RPC_BINDING_VECTOR, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11435         }
11436         ::std::mem::transmute(RpcNsBindingSelect(::std::mem::transmute(bindingvec), ::std::mem::transmute(binding)))
11437     }
11438     #[cfg(not(windows))]
11439     unimplemented!("Unsupported target OS");
11440 }
11441 #[inline]
RpcNsBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11442 pub unsafe fn RpcNsBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11443     #[cfg(windows)]
11444     {
11445         #[link(name = "windows")]
11446         extern "system" {
11447             fn RpcNsBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11448         }
11449         ::std::mem::transmute(RpcNsBindingUnexportA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectuuidvec)))
11450     }
11451     #[cfg(not(windows))]
11452     unimplemented!("Unsupported target OS");
11453 }
11454 #[inline]
RpcNsBindingUnexportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS11455 pub unsafe fn RpcNsBindingUnexportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS {
11456     #[cfg(windows)]
11457     {
11458         #[link(name = "windows")]
11459         extern "system" {
11460             fn RpcNsBindingUnexportPnPA(entrynamesyntax: u32, entryname: *const u8, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS;
11461         }
11462         ::std::mem::transmute(RpcNsBindingUnexportPnPA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectvector)))
11463     }
11464     #[cfg(not(windows))]
11465     unimplemented!("Unsupported target OS");
11466 }
11467 #[inline]
RpcNsBindingUnexportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS11468 pub unsafe fn RpcNsBindingUnexportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS {
11469     #[cfg(windows)]
11470     {
11471         #[link(name = "windows")]
11472         extern "system" {
11473             fn RpcNsBindingUnexportPnPW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectvector: *const UUID_VECTOR) -> RPC_STATUS;
11474         }
11475         ::std::mem::transmute(RpcNsBindingUnexportPnPW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectvector)))
11476     }
11477     #[cfg(not(windows))]
11478     unimplemented!("Unsupported target OS");
11479 }
11480 #[inline]
RpcNsBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11481 pub unsafe fn RpcNsBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11482     #[cfg(windows)]
11483     {
11484         #[link(name = "windows")]
11485         extern "system" {
11486             fn RpcNsBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifspec: *const ::std::ffi::c_void, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11487         }
11488         ::std::mem::transmute(RpcNsBindingUnexportW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifspec), ::std::mem::transmute(objectuuidvec)))
11489     }
11490     #[cfg(not(windows))]
11491     unimplemented!("Unsupported target OS");
11492 }
11493 #[inline]
RpcNsEntryExpandNameA(entrynamesyntax: u32, entryname: *const u8, expandedname: *mut *mut u8) -> RPC_STATUS11494 pub unsafe fn RpcNsEntryExpandNameA(entrynamesyntax: u32, entryname: *const u8, expandedname: *mut *mut u8) -> RPC_STATUS {
11495     #[cfg(windows)]
11496     {
11497         #[link(name = "windows")]
11498         extern "system" {
11499             fn RpcNsEntryExpandNameA(entrynamesyntax: u32, entryname: *const u8, expandedname: *mut *mut u8) -> RPC_STATUS;
11500         }
11501         ::std::mem::transmute(RpcNsEntryExpandNameA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(expandedname)))
11502     }
11503     #[cfg(not(windows))]
11504     unimplemented!("Unsupported target OS");
11505 }
11506 #[inline]
RpcNsEntryExpandNameW(entrynamesyntax: u32, entryname: *const u16, expandedname: *mut *mut u16) -> RPC_STATUS11507 pub unsafe fn RpcNsEntryExpandNameW(entrynamesyntax: u32, entryname: *const u16, expandedname: *mut *mut u16) -> RPC_STATUS {
11508     #[cfg(windows)]
11509     {
11510         #[link(name = "windows")]
11511         extern "system" {
11512             fn RpcNsEntryExpandNameW(entrynamesyntax: u32, entryname: *const u16, expandedname: *mut *mut u16) -> RPC_STATUS;
11513         }
11514         ::std::mem::transmute(RpcNsEntryExpandNameW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(expandedname)))
11515     }
11516     #[cfg(not(windows))]
11517     unimplemented!("Unsupported target OS");
11518 }
11519 #[inline]
RpcNsEntryObjectInqBeginA(entrynamesyntax: u32, entryname: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11520 pub unsafe fn RpcNsEntryObjectInqBeginA(entrynamesyntax: u32, entryname: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11521     #[cfg(windows)]
11522     {
11523         #[link(name = "windows")]
11524         extern "system" {
11525             fn RpcNsEntryObjectInqBeginA(entrynamesyntax: u32, entryname: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11526         }
11527         ::std::mem::transmute(RpcNsEntryObjectInqBeginA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(inquirycontext)))
11528     }
11529     #[cfg(not(windows))]
11530     unimplemented!("Unsupported target OS");
11531 }
11532 #[inline]
RpcNsEntryObjectInqBeginW(entrynamesyntax: u32, entryname: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11533 pub unsafe fn RpcNsEntryObjectInqBeginW(entrynamesyntax: u32, entryname: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11534     #[cfg(windows)]
11535     {
11536         #[link(name = "windows")]
11537         extern "system" {
11538             fn RpcNsEntryObjectInqBeginW(entrynamesyntax: u32, entryname: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11539         }
11540         ::std::mem::transmute(RpcNsEntryObjectInqBeginW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(inquirycontext)))
11541     }
11542     #[cfg(not(windows))]
11543     unimplemented!("Unsupported target OS");
11544 }
11545 #[inline]
RpcNsEntryObjectInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11546 pub unsafe fn RpcNsEntryObjectInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11547     #[cfg(windows)]
11548     {
11549         #[link(name = "windows")]
11550         extern "system" {
11551             fn RpcNsEntryObjectInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11552         }
11553         ::std::mem::transmute(RpcNsEntryObjectInqDone(::std::mem::transmute(inquirycontext)))
11554     }
11555     #[cfg(not(windows))]
11556     unimplemented!("Unsupported target OS");
11557 }
11558 #[inline]
RpcNsEntryObjectInqNext(inquirycontext: *mut ::std::ffi::c_void, objuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS11559 pub unsafe fn RpcNsEntryObjectInqNext(inquirycontext: *mut ::std::ffi::c_void, objuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
11560     #[cfg(windows)]
11561     {
11562         #[link(name = "windows")]
11563         extern "system" {
11564             fn RpcNsEntryObjectInqNext(inquirycontext: *mut ::std::ffi::c_void, objuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
11565         }
11566         ::std::mem::transmute(RpcNsEntryObjectInqNext(::std::mem::transmute(inquirycontext), ::std::mem::transmute(objuuid)))
11567     }
11568     #[cfg(not(windows))]
11569     unimplemented!("Unsupported target OS");
11570 }
11571 #[inline]
RpcNsGroupDeleteA(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u8) -> RPC_STATUS11572 pub unsafe fn RpcNsGroupDeleteA(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u8) -> RPC_STATUS {
11573     #[cfg(windows)]
11574     {
11575         #[link(name = "windows")]
11576         extern "system" {
11577             fn RpcNsGroupDeleteA(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u8) -> RPC_STATUS;
11578         }
11579         ::std::mem::transmute(RpcNsGroupDeleteA(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname)))
11580     }
11581     #[cfg(not(windows))]
11582     unimplemented!("Unsupported target OS");
11583 }
11584 #[inline]
RpcNsGroupDeleteW(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u16) -> RPC_STATUS11585 pub unsafe fn RpcNsGroupDeleteW(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u16) -> RPC_STATUS {
11586     #[cfg(windows)]
11587     {
11588         #[link(name = "windows")]
11589         extern "system" {
11590             fn RpcNsGroupDeleteW(groupnamesyntax: GROUP_NAME_SYNTAX, groupname: *const u16) -> RPC_STATUS;
11591         }
11592         ::std::mem::transmute(RpcNsGroupDeleteW(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname)))
11593     }
11594     #[cfg(not(windows))]
11595     unimplemented!("Unsupported target OS");
11596 }
11597 #[inline]
RpcNsGroupMbrAddA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS11598 pub unsafe fn RpcNsGroupMbrAddA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS {
11599     #[cfg(windows)]
11600     {
11601         #[link(name = "windows")]
11602         extern "system" {
11603             fn RpcNsGroupMbrAddA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS;
11604         }
11605         ::std::mem::transmute(RpcNsGroupMbrAddA(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
11606     }
11607     #[cfg(not(windows))]
11608     unimplemented!("Unsupported target OS");
11609 }
11610 #[inline]
RpcNsGroupMbrAddW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS11611 pub unsafe fn RpcNsGroupMbrAddW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS {
11612     #[cfg(windows)]
11613     {
11614         #[link(name = "windows")]
11615         extern "system" {
11616             fn RpcNsGroupMbrAddW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS;
11617         }
11618         ::std::mem::transmute(RpcNsGroupMbrAddW(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
11619     }
11620     #[cfg(not(windows))]
11621     unimplemented!("Unsupported target OS");
11622 }
11623 #[inline]
RpcNsGroupMbrInqBeginA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11624 pub unsafe fn RpcNsGroupMbrInqBeginA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11625     #[cfg(windows)]
11626     {
11627         #[link(name = "windows")]
11628         extern "system" {
11629             fn RpcNsGroupMbrInqBeginA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11630         }
11631         ::std::mem::transmute(RpcNsGroupMbrInqBeginA(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(inquirycontext)))
11632     }
11633     #[cfg(not(windows))]
11634     unimplemented!("Unsupported target OS");
11635 }
11636 #[inline]
RpcNsGroupMbrInqBeginW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11637 pub unsafe fn RpcNsGroupMbrInqBeginW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11638     #[cfg(windows)]
11639     {
11640         #[link(name = "windows")]
11641         extern "system" {
11642             fn RpcNsGroupMbrInqBeginW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11643         }
11644         ::std::mem::transmute(RpcNsGroupMbrInqBeginW(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(inquirycontext)))
11645     }
11646     #[cfg(not(windows))]
11647     unimplemented!("Unsupported target OS");
11648 }
11649 #[inline]
RpcNsGroupMbrInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11650 pub unsafe fn RpcNsGroupMbrInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11651     #[cfg(windows)]
11652     {
11653         #[link(name = "windows")]
11654         extern "system" {
11655             fn RpcNsGroupMbrInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11656         }
11657         ::std::mem::transmute(RpcNsGroupMbrInqDone(::std::mem::transmute(inquirycontext)))
11658     }
11659     #[cfg(not(windows))]
11660     unimplemented!("Unsupported target OS");
11661 }
11662 #[inline]
RpcNsGroupMbrInqNextA(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u8) -> RPC_STATUS11663 pub unsafe fn RpcNsGroupMbrInqNextA(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u8) -> RPC_STATUS {
11664     #[cfg(windows)]
11665     {
11666         #[link(name = "windows")]
11667         extern "system" {
11668             fn RpcNsGroupMbrInqNextA(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u8) -> RPC_STATUS;
11669         }
11670         ::std::mem::transmute(RpcNsGroupMbrInqNextA(::std::mem::transmute(inquirycontext), ::std::mem::transmute(membername)))
11671     }
11672     #[cfg(not(windows))]
11673     unimplemented!("Unsupported target OS");
11674 }
11675 #[inline]
RpcNsGroupMbrInqNextW(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u16) -> RPC_STATUS11676 pub unsafe fn RpcNsGroupMbrInqNextW(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u16) -> RPC_STATUS {
11677     #[cfg(windows)]
11678     {
11679         #[link(name = "windows")]
11680         extern "system" {
11681             fn RpcNsGroupMbrInqNextW(inquirycontext: *mut ::std::ffi::c_void, membername: *mut *mut u16) -> RPC_STATUS;
11682         }
11683         ::std::mem::transmute(RpcNsGroupMbrInqNextW(::std::mem::transmute(inquirycontext), ::std::mem::transmute(membername)))
11684     }
11685     #[cfg(not(windows))]
11686     unimplemented!("Unsupported target OS");
11687 }
11688 #[inline]
RpcNsGroupMbrRemoveA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS11689 pub unsafe fn RpcNsGroupMbrRemoveA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS {
11690     #[cfg(windows)]
11691     {
11692         #[link(name = "windows")]
11693         extern "system" {
11694             fn RpcNsGroupMbrRemoveA(groupnamesyntax: u32, groupname: *const u8, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS;
11695         }
11696         ::std::mem::transmute(RpcNsGroupMbrRemoveA(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
11697     }
11698     #[cfg(not(windows))]
11699     unimplemented!("Unsupported target OS");
11700 }
11701 #[inline]
RpcNsGroupMbrRemoveW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS11702 pub unsafe fn RpcNsGroupMbrRemoveW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS {
11703     #[cfg(windows)]
11704     {
11705         #[link(name = "windows")]
11706         extern "system" {
11707             fn RpcNsGroupMbrRemoveW(groupnamesyntax: u32, groupname: *const u16, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS;
11708         }
11709         ::std::mem::transmute(RpcNsGroupMbrRemoveW(::std::mem::transmute(groupnamesyntax), ::std::mem::transmute(groupname), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
11710     }
11711     #[cfg(not(windows))]
11712     unimplemented!("Unsupported target OS");
11713 }
11714 #[inline]
RpcNsMgmtBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11715 pub unsafe fn RpcNsMgmtBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11716     #[cfg(windows)]
11717     {
11718         #[link(name = "windows")]
11719         extern "system" {
11720             fn RpcNsMgmtBindingUnexportA(entrynamesyntax: u32, entryname: *const u8, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11721         }
11722         ::std::mem::transmute(RpcNsMgmtBindingUnexportA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifid), ::std::mem::transmute(versoption), ::std::mem::transmute(objectuuidvec)))
11723     }
11724     #[cfg(not(windows))]
11725     unimplemented!("Unsupported target OS");
11726 }
11727 #[inline]
RpcNsMgmtBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS11728 pub unsafe fn RpcNsMgmtBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS {
11729     #[cfg(windows)]
11730     {
11731         #[link(name = "windows")]
11732         extern "system" {
11733             fn RpcNsMgmtBindingUnexportW(entrynamesyntax: u32, entryname: *const u16, ifid: *const RPC_IF_ID, versoption: u32, objectuuidvec: *const UUID_VECTOR) -> RPC_STATUS;
11734         }
11735         ::std::mem::transmute(RpcNsMgmtBindingUnexportW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifid), ::std::mem::transmute(versoption), ::std::mem::transmute(objectuuidvec)))
11736     }
11737     #[cfg(not(windows))]
11738     unimplemented!("Unsupported target OS");
11739 }
11740 #[inline]
RpcNsMgmtEntryCreateA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS11741 pub unsafe fn RpcNsMgmtEntryCreateA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS {
11742     #[cfg(windows)]
11743     {
11744         #[link(name = "windows")]
11745         extern "system" {
11746             fn RpcNsMgmtEntryCreateA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS;
11747         }
11748         ::std::mem::transmute(RpcNsMgmtEntryCreateA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11749     }
11750     #[cfg(not(windows))]
11751     unimplemented!("Unsupported target OS");
11752 }
11753 #[inline]
RpcNsMgmtEntryCreateW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS11754 pub unsafe fn RpcNsMgmtEntryCreateW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS {
11755     #[cfg(windows)]
11756     {
11757         #[link(name = "windows")]
11758         extern "system" {
11759             fn RpcNsMgmtEntryCreateW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS;
11760         }
11761         ::std::mem::transmute(RpcNsMgmtEntryCreateW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11762     }
11763     #[cfg(not(windows))]
11764     unimplemented!("Unsupported target OS");
11765 }
11766 #[inline]
RpcNsMgmtEntryDeleteA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS11767 pub unsafe fn RpcNsMgmtEntryDeleteA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS {
11768     #[cfg(windows)]
11769     {
11770         #[link(name = "windows")]
11771         extern "system" {
11772             fn RpcNsMgmtEntryDeleteA(entrynamesyntax: u32, entryname: *const u8) -> RPC_STATUS;
11773         }
11774         ::std::mem::transmute(RpcNsMgmtEntryDeleteA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11775     }
11776     #[cfg(not(windows))]
11777     unimplemented!("Unsupported target OS");
11778 }
11779 #[inline]
RpcNsMgmtEntryDeleteW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS11780 pub unsafe fn RpcNsMgmtEntryDeleteW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS {
11781     #[cfg(windows)]
11782     {
11783         #[link(name = "windows")]
11784         extern "system" {
11785             fn RpcNsMgmtEntryDeleteW(entrynamesyntax: u32, entryname: *const u16) -> RPC_STATUS;
11786         }
11787         ::std::mem::transmute(RpcNsMgmtEntryDeleteW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname)))
11788     }
11789     #[cfg(not(windows))]
11790     unimplemented!("Unsupported target OS");
11791 }
11792 #[inline]
RpcNsMgmtEntryInqIfIdsA(entrynamesyntax: u32, entryname: *const u8, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS11793 pub unsafe fn RpcNsMgmtEntryInqIfIdsA(entrynamesyntax: u32, entryname: *const u8, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS {
11794     #[cfg(windows)]
11795     {
11796         #[link(name = "windows")]
11797         extern "system" {
11798             fn RpcNsMgmtEntryInqIfIdsA(entrynamesyntax: u32, entryname: *const u8, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS;
11799         }
11800         ::std::mem::transmute(RpcNsMgmtEntryInqIfIdsA(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifidvec)))
11801     }
11802     #[cfg(not(windows))]
11803     unimplemented!("Unsupported target OS");
11804 }
11805 #[inline]
RpcNsMgmtEntryInqIfIdsW(entrynamesyntax: u32, entryname: *const u16, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS11806 pub unsafe fn RpcNsMgmtEntryInqIfIdsW(entrynamesyntax: u32, entryname: *const u16, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS {
11807     #[cfg(windows)]
11808     {
11809         #[link(name = "windows")]
11810         extern "system" {
11811             fn RpcNsMgmtEntryInqIfIdsW(entrynamesyntax: u32, entryname: *const u16, ifidvec: *mut *mut RPC_IF_ID_VECTOR) -> RPC_STATUS;
11812         }
11813         ::std::mem::transmute(RpcNsMgmtEntryInqIfIdsW(::std::mem::transmute(entrynamesyntax), ::std::mem::transmute(entryname), ::std::mem::transmute(ifidvec)))
11814     }
11815     #[cfg(not(windows))]
11816     unimplemented!("Unsupported target OS");
11817 }
11818 #[inline]
RpcNsMgmtHandleSetExpAge(nshandle: *mut ::std::ffi::c_void, expirationage: u32) -> RPC_STATUS11819 pub unsafe fn RpcNsMgmtHandleSetExpAge(nshandle: *mut ::std::ffi::c_void, expirationage: u32) -> RPC_STATUS {
11820     #[cfg(windows)]
11821     {
11822         #[link(name = "windows")]
11823         extern "system" {
11824             fn RpcNsMgmtHandleSetExpAge(nshandle: *mut ::std::ffi::c_void, expirationage: u32) -> RPC_STATUS;
11825         }
11826         ::std::mem::transmute(RpcNsMgmtHandleSetExpAge(::std::mem::transmute(nshandle), ::std::mem::transmute(expirationage)))
11827     }
11828     #[cfg(not(windows))]
11829     unimplemented!("Unsupported target OS");
11830 }
11831 #[inline]
RpcNsMgmtInqExpAge(expirationage: *mut u32) -> RPC_STATUS11832 pub unsafe fn RpcNsMgmtInqExpAge(expirationage: *mut u32) -> RPC_STATUS {
11833     #[cfg(windows)]
11834     {
11835         #[link(name = "windows")]
11836         extern "system" {
11837             fn RpcNsMgmtInqExpAge(expirationage: *mut u32) -> RPC_STATUS;
11838         }
11839         ::std::mem::transmute(RpcNsMgmtInqExpAge(::std::mem::transmute(expirationage)))
11840     }
11841     #[cfg(not(windows))]
11842     unimplemented!("Unsupported target OS");
11843 }
11844 #[inline]
RpcNsMgmtSetExpAge(expirationage: u32) -> RPC_STATUS11845 pub unsafe fn RpcNsMgmtSetExpAge(expirationage: u32) -> RPC_STATUS {
11846     #[cfg(windows)]
11847     {
11848         #[link(name = "windows")]
11849         extern "system" {
11850             fn RpcNsMgmtSetExpAge(expirationage: u32) -> RPC_STATUS;
11851         }
11852         ::std::mem::transmute(RpcNsMgmtSetExpAge(::std::mem::transmute(expirationage)))
11853     }
11854     #[cfg(not(windows))]
11855     unimplemented!("Unsupported target OS");
11856 }
11857 #[inline]
RpcNsProfileDeleteA(profilenamesyntax: u32, profilename: *const u8) -> RPC_STATUS11858 pub unsafe fn RpcNsProfileDeleteA(profilenamesyntax: u32, profilename: *const u8) -> RPC_STATUS {
11859     #[cfg(windows)]
11860     {
11861         #[link(name = "windows")]
11862         extern "system" {
11863             fn RpcNsProfileDeleteA(profilenamesyntax: u32, profilename: *const u8) -> RPC_STATUS;
11864         }
11865         ::std::mem::transmute(RpcNsProfileDeleteA(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename)))
11866     }
11867     #[cfg(not(windows))]
11868     unimplemented!("Unsupported target OS");
11869 }
11870 #[inline]
RpcNsProfileDeleteW(profilenamesyntax: u32, profilename: *const u16) -> RPC_STATUS11871 pub unsafe fn RpcNsProfileDeleteW(profilenamesyntax: u32, profilename: *const u16) -> RPC_STATUS {
11872     #[cfg(windows)]
11873     {
11874         #[link(name = "windows")]
11875         extern "system" {
11876             fn RpcNsProfileDeleteW(profilenamesyntax: u32, profilename: *const u16) -> RPC_STATUS;
11877         }
11878         ::std::mem::transmute(RpcNsProfileDeleteW(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename)))
11879     }
11880     #[cfg(not(windows))]
11881     unimplemented!("Unsupported target OS");
11882 }
11883 #[inline]
RpcNsProfileEltAddA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8, priority: u32, annotation: *const u8) -> RPC_STATUS11884 pub unsafe fn RpcNsProfileEltAddA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8, priority: u32, annotation: *const u8) -> RPC_STATUS {
11885     #[cfg(windows)]
11886     {
11887         #[link(name = "windows")]
11888         extern "system" {
11889             fn RpcNsProfileEltAddA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8, priority: u32, annotation: *const u8) -> RPC_STATUS;
11890         }
11891         ::std::mem::transmute(RpcNsProfileEltAddA(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename), ::std::mem::transmute(ifid), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername), ::std::mem::transmute(priority), ::std::mem::transmute(annotation)))
11892     }
11893     #[cfg(not(windows))]
11894     unimplemented!("Unsupported target OS");
11895 }
11896 #[inline]
RpcNsProfileEltAddW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16, priority: u32, annotation: *const u16) -> RPC_STATUS11897 pub unsafe fn RpcNsProfileEltAddW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16, priority: u32, annotation: *const u16) -> RPC_STATUS {
11898     #[cfg(windows)]
11899     {
11900         #[link(name = "windows")]
11901         extern "system" {
11902             fn RpcNsProfileEltAddW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16, priority: u32, annotation: *const u16) -> RPC_STATUS;
11903         }
11904         ::std::mem::transmute(RpcNsProfileEltAddW(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename), ::std::mem::transmute(ifid), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername), ::std::mem::transmute(priority), ::std::mem::transmute(annotation)))
11905     }
11906     #[cfg(not(windows))]
11907     unimplemented!("Unsupported target OS");
11908 }
11909 #[inline]
RpcNsProfileEltInqBeginA(profilenamesyntax: u32, profilename: *const u8, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11910 pub unsafe fn RpcNsProfileEltInqBeginA(profilenamesyntax: u32, profilename: *const u8, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11911     #[cfg(windows)]
11912     {
11913         #[link(name = "windows")]
11914         extern "system" {
11915             fn RpcNsProfileEltInqBeginA(profilenamesyntax: u32, profilename: *const u8, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u8, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11916         }
11917         ::std::mem::transmute(RpcNsProfileEltInqBeginA(
11918             ::std::mem::transmute(profilenamesyntax),
11919             ::std::mem::transmute(profilename),
11920             ::std::mem::transmute(inquirytype),
11921             ::std::mem::transmute(ifid),
11922             ::std::mem::transmute(versoption),
11923             ::std::mem::transmute(membernamesyntax),
11924             ::std::mem::transmute(membername),
11925             ::std::mem::transmute(inquirycontext),
11926         ))
11927     }
11928     #[cfg(not(windows))]
11929     unimplemented!("Unsupported target OS");
11930 }
11931 #[inline]
RpcNsProfileEltInqBeginW(profilenamesyntax: u32, profilename: *const u16, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11932 pub unsafe fn RpcNsProfileEltInqBeginW(profilenamesyntax: u32, profilename: *const u16, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11933     #[cfg(windows)]
11934     {
11935         #[link(name = "windows")]
11936         extern "system" {
11937             fn RpcNsProfileEltInqBeginW(profilenamesyntax: u32, profilename: *const u16, inquirytype: u32, ifid: *const RPC_IF_ID, versoption: u32, membernamesyntax: u32, membername: *const u16, inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11938         }
11939         ::std::mem::transmute(RpcNsProfileEltInqBeginW(
11940             ::std::mem::transmute(profilenamesyntax),
11941             ::std::mem::transmute(profilename),
11942             ::std::mem::transmute(inquirytype),
11943             ::std::mem::transmute(ifid),
11944             ::std::mem::transmute(versoption),
11945             ::std::mem::transmute(membernamesyntax),
11946             ::std::mem::transmute(membername),
11947             ::std::mem::transmute(inquirycontext),
11948         ))
11949     }
11950     #[cfg(not(windows))]
11951     unimplemented!("Unsupported target OS");
11952 }
11953 #[inline]
RpcNsProfileEltInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS11954 pub unsafe fn RpcNsProfileEltInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
11955     #[cfg(windows)]
11956     {
11957         #[link(name = "windows")]
11958         extern "system" {
11959             fn RpcNsProfileEltInqDone(inquirycontext: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
11960         }
11961         ::std::mem::transmute(RpcNsProfileEltInqDone(::std::mem::transmute(inquirycontext)))
11962     }
11963     #[cfg(not(windows))]
11964     unimplemented!("Unsupported target OS");
11965 }
11966 #[inline]
RpcNsProfileEltInqNextA(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u8, priority: *mut u32, annotation: *mut *mut u8) -> RPC_STATUS11967 pub unsafe fn RpcNsProfileEltInqNextA(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u8, priority: *mut u32, annotation: *mut *mut u8) -> RPC_STATUS {
11968     #[cfg(windows)]
11969     {
11970         #[link(name = "windows")]
11971         extern "system" {
11972             fn RpcNsProfileEltInqNextA(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u8, priority: *mut u32, annotation: *mut *mut u8) -> RPC_STATUS;
11973         }
11974         ::std::mem::transmute(RpcNsProfileEltInqNextA(::std::mem::transmute(inquirycontext), ::std::mem::transmute(ifid), ::std::mem::transmute(membername), ::std::mem::transmute(priority), ::std::mem::transmute(annotation)))
11975     }
11976     #[cfg(not(windows))]
11977     unimplemented!("Unsupported target OS");
11978 }
11979 #[inline]
RpcNsProfileEltInqNextW(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u16, priority: *mut u32, annotation: *mut *mut u16) -> RPC_STATUS11980 pub unsafe fn RpcNsProfileEltInqNextW(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u16, priority: *mut u32, annotation: *mut *mut u16) -> RPC_STATUS {
11981     #[cfg(windows)]
11982     {
11983         #[link(name = "windows")]
11984         extern "system" {
11985             fn RpcNsProfileEltInqNextW(inquirycontext: *const ::std::ffi::c_void, ifid: *mut RPC_IF_ID, membername: *mut *mut u16, priority: *mut u32, annotation: *mut *mut u16) -> RPC_STATUS;
11986         }
11987         ::std::mem::transmute(RpcNsProfileEltInqNextW(::std::mem::transmute(inquirycontext), ::std::mem::transmute(ifid), ::std::mem::transmute(membername), ::std::mem::transmute(priority), ::std::mem::transmute(annotation)))
11988     }
11989     #[cfg(not(windows))]
11990     unimplemented!("Unsupported target OS");
11991 }
11992 #[inline]
RpcNsProfileEltRemoveA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS11993 pub unsafe fn RpcNsProfileEltRemoveA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS {
11994     #[cfg(windows)]
11995     {
11996         #[link(name = "windows")]
11997         extern "system" {
11998             fn RpcNsProfileEltRemoveA(profilenamesyntax: u32, profilename: *const u8, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u8) -> RPC_STATUS;
11999         }
12000         ::std::mem::transmute(RpcNsProfileEltRemoveA(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename), ::std::mem::transmute(ifid), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
12001     }
12002     #[cfg(not(windows))]
12003     unimplemented!("Unsupported target OS");
12004 }
12005 #[inline]
RpcNsProfileEltRemoveW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS12006 pub unsafe fn RpcNsProfileEltRemoveW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS {
12007     #[cfg(windows)]
12008     {
12009         #[link(name = "windows")]
12010         extern "system" {
12011             fn RpcNsProfileEltRemoveW(profilenamesyntax: u32, profilename: *const u16, ifid: *const RPC_IF_ID, membernamesyntax: u32, membername: *const u16) -> RPC_STATUS;
12012         }
12013         ::std::mem::transmute(RpcNsProfileEltRemoveW(::std::mem::transmute(profilenamesyntax), ::std::mem::transmute(profilename), ::std::mem::transmute(ifid), ::std::mem::transmute(membernamesyntax), ::std::mem::transmute(membername)))
12014     }
12015     #[cfg(not(windows))]
12016     unimplemented!("Unsupported target OS");
12017 }
12018 #[inline]
RpcObjectInqType(objuuid: *const ::windows::runtime::GUID, typeuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS12019 pub unsafe fn RpcObjectInqType(objuuid: *const ::windows::runtime::GUID, typeuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
12020     #[cfg(windows)]
12021     {
12022         #[link(name = "windows")]
12023         extern "system" {
12024             fn RpcObjectInqType(objuuid: *const ::windows::runtime::GUID, typeuuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
12025         }
12026         ::std::mem::transmute(RpcObjectInqType(::std::mem::transmute(objuuid), ::std::mem::transmute(typeuuid)))
12027     }
12028     #[cfg(not(windows))]
12029     unimplemented!("Unsupported target OS");
12030 }
12031 #[inline]
RpcObjectSetInqFn(inquiryfn: ::std::option::Option<RPC_OBJECT_INQ_FN>) -> RPC_STATUS12032 pub unsafe fn RpcObjectSetInqFn(inquiryfn: ::std::option::Option<RPC_OBJECT_INQ_FN>) -> RPC_STATUS {
12033     #[cfg(windows)]
12034     {
12035         #[link(name = "windows")]
12036         extern "system" {
12037             fn RpcObjectSetInqFn(inquiryfn: ::windows::runtime::RawPtr) -> RPC_STATUS;
12038         }
12039         ::std::mem::transmute(RpcObjectSetInqFn(::std::mem::transmute(inquiryfn)))
12040     }
12041     #[cfg(not(windows))]
12042     unimplemented!("Unsupported target OS");
12043 }
12044 #[inline]
RpcObjectSetType(objuuid: *const ::windows::runtime::GUID, typeuuid: *const ::windows::runtime::GUID) -> RPC_STATUS12045 pub unsafe fn RpcObjectSetType(objuuid: *const ::windows::runtime::GUID, typeuuid: *const ::windows::runtime::GUID) -> RPC_STATUS {
12046     #[cfg(windows)]
12047     {
12048         #[link(name = "windows")]
12049         extern "system" {
12050             fn RpcObjectSetType(objuuid: *const ::windows::runtime::GUID, typeuuid: *const ::windows::runtime::GUID) -> RPC_STATUS;
12051         }
12052         ::std::mem::transmute(RpcObjectSetType(::std::mem::transmute(objuuid), ::std::mem::transmute(typeuuid)))
12053     }
12054     #[cfg(not(windows))]
12055     unimplemented!("Unsupported target OS");
12056 }
12057 #[inline]
RpcProtseqVectorFreeA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS12058 pub unsafe fn RpcProtseqVectorFreeA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS {
12059     #[cfg(windows)]
12060     {
12061         #[link(name = "windows")]
12062         extern "system" {
12063             fn RpcProtseqVectorFreeA(protseqvector: *mut *mut RPC_PROTSEQ_VECTORA) -> RPC_STATUS;
12064         }
12065         ::std::mem::transmute(RpcProtseqVectorFreeA(::std::mem::transmute(protseqvector)))
12066     }
12067     #[cfg(not(windows))]
12068     unimplemented!("Unsupported target OS");
12069 }
12070 #[inline]
RpcProtseqVectorFreeW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS12071 pub unsafe fn RpcProtseqVectorFreeW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS {
12072     #[cfg(windows)]
12073     {
12074         #[link(name = "windows")]
12075         extern "system" {
12076             fn RpcProtseqVectorFreeW(protseqvector: *mut *mut RPC_PROTSEQ_VECTORW) -> RPC_STATUS;
12077         }
12078         ::std::mem::transmute(RpcProtseqVectorFreeW(::std::mem::transmute(protseqvector)))
12079     }
12080     #[cfg(not(windows))]
12081     unimplemented!("Unsupported target OS");
12082 }
12083 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12084 #[repr(transparent)]
12085 pub struct RpcProxyPerfCounters(pub i32);
12086 pub const RpcCurrentUniqueUser: RpcProxyPerfCounters = RpcProxyPerfCounters(1i32);
12087 pub const RpcBackEndConnectionAttempts: RpcProxyPerfCounters = RpcProxyPerfCounters(2i32);
12088 pub const RpcBackEndConnectionFailed: RpcProxyPerfCounters = RpcProxyPerfCounters(3i32);
12089 pub const RpcRequestsPerSecond: RpcProxyPerfCounters = RpcProxyPerfCounters(4i32);
12090 pub const RpcIncomingConnections: RpcProxyPerfCounters = RpcProxyPerfCounters(5i32);
12091 pub const RpcIncomingBandwidth: RpcProxyPerfCounters = RpcProxyPerfCounters(6i32);
12092 pub const RpcOutgoingBandwidth: RpcProxyPerfCounters = RpcProxyPerfCounters(7i32);
12093 pub const RpcAttemptedLbsDecisions: RpcProxyPerfCounters = RpcProxyPerfCounters(8i32);
12094 pub const RpcFailedLbsDecisions: RpcProxyPerfCounters = RpcProxyPerfCounters(9i32);
12095 pub const RpcAttemptedLbsMessages: RpcProxyPerfCounters = RpcProxyPerfCounters(10i32);
12096 pub const RpcFailedLbsMessages: RpcProxyPerfCounters = RpcProxyPerfCounters(11i32);
12097 pub const RpcLastCounter: RpcProxyPerfCounters = RpcProxyPerfCounters(12i32);
12098 impl ::std::convert::From<i32> for RpcProxyPerfCounters {
from(value: i32) -> Self12099     fn from(value: i32) -> Self {
12100         Self(value)
12101     }
12102 }
12103 unsafe impl ::windows::runtime::Abi for RpcProxyPerfCounters {
12104     type Abi = Self;
12105     type DefaultType = Self;
12106 }
12107 #[inline]
RpcRaiseException(exception: RPC_STATUS)12108 pub unsafe fn RpcRaiseException(exception: RPC_STATUS) {
12109     #[cfg(windows)]
12110     {
12111         #[link(name = "windows")]
12112         extern "system" {
12113             fn RpcRaiseException(exception: RPC_STATUS);
12114         }
12115         ::std::mem::transmute(RpcRaiseException(::std::mem::transmute(exception)))
12116     }
12117     #[cfg(not(windows))]
12118     unimplemented!("Unsupported target OS");
12119 }
12120 #[inline]
RpcRevertContainerImpersonation() -> RPC_STATUS12121 pub unsafe fn RpcRevertContainerImpersonation() -> RPC_STATUS {
12122     #[cfg(windows)]
12123     {
12124         #[link(name = "windows")]
12125         extern "system" {
12126             fn RpcRevertContainerImpersonation() -> RPC_STATUS;
12127         }
12128         ::std::mem::transmute(RpcRevertContainerImpersonation())
12129     }
12130     #[cfg(not(windows))]
12131     unimplemented!("Unsupported target OS");
12132 }
12133 #[inline]
RpcRevertToSelf() -> RPC_STATUS12134 pub unsafe fn RpcRevertToSelf() -> RPC_STATUS {
12135     #[cfg(windows)]
12136     {
12137         #[link(name = "windows")]
12138         extern "system" {
12139             fn RpcRevertToSelf() -> RPC_STATUS;
12140         }
12141         ::std::mem::transmute(RpcRevertToSelf())
12142     }
12143     #[cfg(not(windows))]
12144     unimplemented!("Unsupported target OS");
12145 }
12146 #[inline]
RpcRevertToSelfEx(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS12147 pub unsafe fn RpcRevertToSelfEx(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS {
12148     #[cfg(windows)]
12149     {
12150         #[link(name = "windows")]
12151         extern "system" {
12152             fn RpcRevertToSelfEx(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS;
12153         }
12154         ::std::mem::transmute(RpcRevertToSelfEx(::std::mem::transmute(bindinghandle)))
12155     }
12156     #[cfg(not(windows))]
12157     unimplemented!("Unsupported target OS");
12158 }
12159 #[inline]
RpcServerCompleteSecurityCallback(bindinghandle: *const ::std::ffi::c_void, status: RPC_STATUS) -> RPC_STATUS12160 pub unsafe fn RpcServerCompleteSecurityCallback(bindinghandle: *const ::std::ffi::c_void, status: RPC_STATUS) -> RPC_STATUS {
12161     #[cfg(windows)]
12162     {
12163         #[link(name = "windows")]
12164         extern "system" {
12165             fn RpcServerCompleteSecurityCallback(bindinghandle: *const ::std::ffi::c_void, status: RPC_STATUS) -> RPC_STATUS;
12166         }
12167         ::std::mem::transmute(RpcServerCompleteSecurityCallback(::std::mem::transmute(bindinghandle), ::std::mem::transmute(status)))
12168     }
12169     #[cfg(not(windows))]
12170     unimplemented!("Unsupported target OS");
12171 }
12172 #[inline]
RpcServerInqBindingHandle(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS12173 pub unsafe fn RpcServerInqBindingHandle(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
12174     #[cfg(windows)]
12175     {
12176         #[link(name = "windows")]
12177         extern "system" {
12178             fn RpcServerInqBindingHandle(binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
12179         }
12180         ::std::mem::transmute(RpcServerInqBindingHandle(::std::mem::transmute(binding)))
12181     }
12182     #[cfg(not(windows))]
12183     unimplemented!("Unsupported target OS");
12184 }
12185 #[inline]
RpcServerInqBindings(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS12186 pub unsafe fn RpcServerInqBindings(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS {
12187     #[cfg(windows)]
12188     {
12189         #[link(name = "windows")]
12190         extern "system" {
12191             fn RpcServerInqBindings(bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS;
12192         }
12193         ::std::mem::transmute(RpcServerInqBindings(::std::mem::transmute(bindingvector)))
12194     }
12195     #[cfg(not(windows))]
12196     unimplemented!("Unsupported target OS");
12197 }
12198 #[inline]
RpcServerInqBindingsEx(securitydescriptor: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS12199 pub unsafe fn RpcServerInqBindingsEx(securitydescriptor: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS {
12200     #[cfg(windows)]
12201     {
12202         #[link(name = "windows")]
12203         extern "system" {
12204             fn RpcServerInqBindingsEx(securitydescriptor: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS;
12205         }
12206         ::std::mem::transmute(RpcServerInqBindingsEx(::std::mem::transmute(securitydescriptor), ::std::mem::transmute(bindingvector)))
12207     }
12208     #[cfg(not(windows))]
12209     unimplemented!("Unsupported target OS");
12210 }
12211 #[inline]
RpcServerInqCallAttributesA(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS12212 pub unsafe fn RpcServerInqCallAttributesA(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS {
12213     #[cfg(windows)]
12214     {
12215         #[link(name = "windows")]
12216         extern "system" {
12217             fn RpcServerInqCallAttributesA(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS;
12218         }
12219         ::std::mem::transmute(RpcServerInqCallAttributesA(::std::mem::transmute(clientbinding), ::std::mem::transmute(rpccallattributes)))
12220     }
12221     #[cfg(not(windows))]
12222     unimplemented!("Unsupported target OS");
12223 }
12224 #[inline]
RpcServerInqCallAttributesW(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS12225 pub unsafe fn RpcServerInqCallAttributesW(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS {
12226     #[cfg(windows)]
12227     {
12228         #[link(name = "windows")]
12229         extern "system" {
12230             fn RpcServerInqCallAttributesW(clientbinding: *const ::std::ffi::c_void, rpccallattributes: *mut ::std::ffi::c_void) -> RPC_STATUS;
12231         }
12232         ::std::mem::transmute(RpcServerInqCallAttributesW(::std::mem::transmute(clientbinding), ::std::mem::transmute(rpccallattributes)))
12233     }
12234     #[cfg(not(windows))]
12235     unimplemented!("Unsupported target OS");
12236 }
12237 #[inline]
RpcServerInqDefaultPrincNameA(authnsvc: u32, princname: *mut *mut u8) -> RPC_STATUS12238 pub unsafe fn RpcServerInqDefaultPrincNameA(authnsvc: u32, princname: *mut *mut u8) -> RPC_STATUS {
12239     #[cfg(windows)]
12240     {
12241         #[link(name = "windows")]
12242         extern "system" {
12243             fn RpcServerInqDefaultPrincNameA(authnsvc: u32, princname: *mut *mut u8) -> RPC_STATUS;
12244         }
12245         ::std::mem::transmute(RpcServerInqDefaultPrincNameA(::std::mem::transmute(authnsvc), ::std::mem::transmute(princname)))
12246     }
12247     #[cfg(not(windows))]
12248     unimplemented!("Unsupported target OS");
12249 }
12250 #[inline]
RpcServerInqDefaultPrincNameW(authnsvc: u32, princname: *mut *mut u16) -> RPC_STATUS12251 pub unsafe fn RpcServerInqDefaultPrincNameW(authnsvc: u32, princname: *mut *mut u16) -> RPC_STATUS {
12252     #[cfg(windows)]
12253     {
12254         #[link(name = "windows")]
12255         extern "system" {
12256             fn RpcServerInqDefaultPrincNameW(authnsvc: u32, princname: *mut *mut u16) -> RPC_STATUS;
12257         }
12258         ::std::mem::transmute(RpcServerInqDefaultPrincNameW(::std::mem::transmute(authnsvc), ::std::mem::transmute(princname)))
12259     }
12260     #[cfg(not(windows))]
12261     unimplemented!("Unsupported target OS");
12262 }
12263 #[inline]
RpcServerInqIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *mut *mut ::std::ffi::c_void) -> RPC_STATUS12264 pub unsafe fn RpcServerInqIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
12265     #[cfg(windows)]
12266     {
12267         #[link(name = "windows")]
12268         extern "system" {
12269             fn RpcServerInqIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
12270         }
12271         ::std::mem::transmute(RpcServerInqIf(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(mgrepv)))
12272     }
12273     #[cfg(not(windows))]
12274     unimplemented!("Unsupported target OS");
12275 }
12276 #[inline]
RpcServerInterfaceGroupActivate(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS12277 pub unsafe fn RpcServerInterfaceGroupActivate(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS {
12278     #[cfg(windows)]
12279     {
12280         #[link(name = "windows")]
12281         extern "system" {
12282             fn RpcServerInterfaceGroupActivate(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS;
12283         }
12284         ::std::mem::transmute(RpcServerInterfaceGroupActivate(::std::mem::transmute(ifgroup)))
12285     }
12286     #[cfg(not(windows))]
12287     unimplemented!("Unsupported target OS");
12288 }
12289 #[inline]
RpcServerInterfaceGroupClose(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS12290 pub unsafe fn RpcServerInterfaceGroupClose(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS {
12291     #[cfg(windows)]
12292     {
12293         #[link(name = "windows")]
12294         extern "system" {
12295             fn RpcServerInterfaceGroupClose(ifgroup: *const ::std::ffi::c_void) -> RPC_STATUS;
12296         }
12297         ::std::mem::transmute(RpcServerInterfaceGroupClose(::std::mem::transmute(ifgroup)))
12298     }
12299     #[cfg(not(windows))]
12300     unimplemented!("Unsupported target OS");
12301 }
12302 #[inline]
RpcServerInterfaceGroupCreateA(interfaces: *const RPC_INTERFACE_TEMPLATEA, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEA, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::std::option::Option<RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN>, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS12303 pub unsafe fn RpcServerInterfaceGroupCreateA(interfaces: *const RPC_INTERFACE_TEMPLATEA, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEA, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::std::option::Option<RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN>, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
12304     #[cfg(windows)]
12305     {
12306         #[link(name = "windows")]
12307         extern "system" {
12308             fn RpcServerInterfaceGroupCreateA(interfaces: *const ::std::mem::ManuallyDrop<RPC_INTERFACE_TEMPLATEA>, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEA, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::windows::runtime::RawPtr, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
12309         }
12310         ::std::mem::transmute(RpcServerInterfaceGroupCreateA(
12311             ::std::mem::transmute(interfaces),
12312             ::std::mem::transmute(numifs),
12313             ::std::mem::transmute(endpoints),
12314             ::std::mem::transmute(numendpoints),
12315             ::std::mem::transmute(idleperiod),
12316             ::std::mem::transmute(idlecallbackfn),
12317             ::std::mem::transmute(idlecallbackcontext),
12318             ::std::mem::transmute(ifgroup),
12319         ))
12320     }
12321     #[cfg(not(windows))]
12322     unimplemented!("Unsupported target OS");
12323 }
12324 #[inline]
RpcServerInterfaceGroupCreateW(interfaces: *const RPC_INTERFACE_TEMPLATEW, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEW, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::std::option::Option<RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN>, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS12325 pub unsafe fn RpcServerInterfaceGroupCreateW(interfaces: *const RPC_INTERFACE_TEMPLATEW, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEW, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::std::option::Option<RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN>, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
12326     #[cfg(windows)]
12327     {
12328         #[link(name = "windows")]
12329         extern "system" {
12330             fn RpcServerInterfaceGroupCreateW(interfaces: *const ::std::mem::ManuallyDrop<RPC_INTERFACE_TEMPLATEW>, numifs: u32, endpoints: *const RPC_ENDPOINT_TEMPLATEW, numendpoints: u32, idleperiod: u32, idlecallbackfn: ::windows::runtime::RawPtr, idlecallbackcontext: *const ::std::ffi::c_void, ifgroup: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
12331         }
12332         ::std::mem::transmute(RpcServerInterfaceGroupCreateW(
12333             ::std::mem::transmute(interfaces),
12334             ::std::mem::transmute(numifs),
12335             ::std::mem::transmute(endpoints),
12336             ::std::mem::transmute(numendpoints),
12337             ::std::mem::transmute(idleperiod),
12338             ::std::mem::transmute(idlecallbackfn),
12339             ::std::mem::transmute(idlecallbackcontext),
12340             ::std::mem::transmute(ifgroup),
12341         ))
12342     }
12343     #[cfg(not(windows))]
12344     unimplemented!("Unsupported target OS");
12345 }
12346 #[inline]
RpcServerInterfaceGroupDeactivate(ifgroup: *const ::std::ffi::c_void, forcedeactivation: u32) -> RPC_STATUS12347 pub unsafe fn RpcServerInterfaceGroupDeactivate(ifgroup: *const ::std::ffi::c_void, forcedeactivation: u32) -> RPC_STATUS {
12348     #[cfg(windows)]
12349     {
12350         #[link(name = "windows")]
12351         extern "system" {
12352             fn RpcServerInterfaceGroupDeactivate(ifgroup: *const ::std::ffi::c_void, forcedeactivation: u32) -> RPC_STATUS;
12353         }
12354         ::std::mem::transmute(RpcServerInterfaceGroupDeactivate(::std::mem::transmute(ifgroup), ::std::mem::transmute(forcedeactivation)))
12355     }
12356     #[cfg(not(windows))]
12357     unimplemented!("Unsupported target OS");
12358 }
12359 #[inline]
RpcServerInterfaceGroupInqBindings(ifgroup: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS12360 pub unsafe fn RpcServerInterfaceGroupInqBindings(ifgroup: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS {
12361     #[cfg(windows)]
12362     {
12363         #[link(name = "windows")]
12364         extern "system" {
12365             fn RpcServerInterfaceGroupInqBindings(ifgroup: *const ::std::ffi::c_void, bindingvector: *mut *mut RPC_BINDING_VECTOR) -> RPC_STATUS;
12366         }
12367         ::std::mem::transmute(RpcServerInterfaceGroupInqBindings(::std::mem::transmute(ifgroup), ::std::mem::transmute(bindingvector)))
12368     }
12369     #[cfg(not(windows))]
12370     unimplemented!("Unsupported target OS");
12371 }
12372 #[inline]
RpcServerListen(minimumcallthreads: u32, maxcalls: u32, dontwait: u32) -> RPC_STATUS12373 pub unsafe fn RpcServerListen(minimumcallthreads: u32, maxcalls: u32, dontwait: u32) -> RPC_STATUS {
12374     #[cfg(windows)]
12375     {
12376         #[link(name = "windows")]
12377         extern "system" {
12378             fn RpcServerListen(minimumcallthreads: u32, maxcalls: u32, dontwait: u32) -> RPC_STATUS;
12379         }
12380         ::std::mem::transmute(RpcServerListen(::std::mem::transmute(minimumcallthreads), ::std::mem::transmute(maxcalls), ::std::mem::transmute(dontwait)))
12381     }
12382     #[cfg(not(windows))]
12383     unimplemented!("Unsupported target OS");
12384 }
12385 #[inline]
RpcServerRegisterAuthInfoA(serverprincname: *const u8, authnsvc: u32, getkeyfn: ::std::option::Option<RPC_AUTH_KEY_RETRIEVAL_FN>, arg: *const ::std::ffi::c_void) -> RPC_STATUS12386 pub unsafe fn RpcServerRegisterAuthInfoA(serverprincname: *const u8, authnsvc: u32, getkeyfn: ::std::option::Option<RPC_AUTH_KEY_RETRIEVAL_FN>, arg: *const ::std::ffi::c_void) -> RPC_STATUS {
12387     #[cfg(windows)]
12388     {
12389         #[link(name = "windows")]
12390         extern "system" {
12391             fn RpcServerRegisterAuthInfoA(serverprincname: *const u8, authnsvc: u32, getkeyfn: ::windows::runtime::RawPtr, arg: *const ::std::ffi::c_void) -> RPC_STATUS;
12392         }
12393         ::std::mem::transmute(RpcServerRegisterAuthInfoA(::std::mem::transmute(serverprincname), ::std::mem::transmute(authnsvc), ::std::mem::transmute(getkeyfn), ::std::mem::transmute(arg)))
12394     }
12395     #[cfg(not(windows))]
12396     unimplemented!("Unsupported target OS");
12397 }
12398 #[inline]
RpcServerRegisterAuthInfoW(serverprincname: *const u16, authnsvc: u32, getkeyfn: ::std::option::Option<RPC_AUTH_KEY_RETRIEVAL_FN>, arg: *const ::std::ffi::c_void) -> RPC_STATUS12399 pub unsafe fn RpcServerRegisterAuthInfoW(serverprincname: *const u16, authnsvc: u32, getkeyfn: ::std::option::Option<RPC_AUTH_KEY_RETRIEVAL_FN>, arg: *const ::std::ffi::c_void) -> RPC_STATUS {
12400     #[cfg(windows)]
12401     {
12402         #[link(name = "windows")]
12403         extern "system" {
12404             fn RpcServerRegisterAuthInfoW(serverprincname: *const u16, authnsvc: u32, getkeyfn: ::windows::runtime::RawPtr, arg: *const ::std::ffi::c_void) -> RPC_STATUS;
12405         }
12406         ::std::mem::transmute(RpcServerRegisterAuthInfoW(::std::mem::transmute(serverprincname), ::std::mem::transmute(authnsvc), ::std::mem::transmute(getkeyfn), ::std::mem::transmute(arg)))
12407     }
12408     #[cfg(not(windows))]
12409     unimplemented!("Unsupported target OS");
12410 }
12411 #[inline]
RpcServerRegisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void) -> RPC_STATUS12412 pub unsafe fn RpcServerRegisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void) -> RPC_STATUS {
12413     #[cfg(windows)]
12414     {
12415         #[link(name = "windows")]
12416         extern "system" {
12417             fn RpcServerRegisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void) -> RPC_STATUS;
12418         }
12419         ::std::mem::transmute(RpcServerRegisterIf(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(mgrepv)))
12420     }
12421     #[cfg(not(windows))]
12422     unimplemented!("Unsupported target OS");
12423 }
12424 #[inline]
RpcServerRegisterIf2(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallbackfn: ::std::option::Option<RPC_IF_CALLBACK_FN>) -> RPC_STATUS12425 pub unsafe fn RpcServerRegisterIf2(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallbackfn: ::std::option::Option<RPC_IF_CALLBACK_FN>) -> RPC_STATUS {
12426     #[cfg(windows)]
12427     {
12428         #[link(name = "windows")]
12429         extern "system" {
12430             fn RpcServerRegisterIf2(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallbackfn: ::windows::runtime::RawPtr) -> RPC_STATUS;
12431         }
12432         ::std::mem::transmute(RpcServerRegisterIf2(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(mgrepv), ::std::mem::transmute(flags), ::std::mem::transmute(maxcalls), ::std::mem::transmute(maxrpcsize), ::std::mem::transmute(ifcallbackfn)))
12433     }
12434     #[cfg(not(windows))]
12435     unimplemented!("Unsupported target OS");
12436 }
12437 #[inline]
RpcServerRegisterIf3(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallback: ::std::option::Option<RPC_IF_CALLBACK_FN>, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12438 pub unsafe fn RpcServerRegisterIf3(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallback: ::std::option::Option<RPC_IF_CALLBACK_FN>, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12439     #[cfg(windows)]
12440     {
12441         #[link(name = "windows")]
12442         extern "system" {
12443             fn RpcServerRegisterIf3(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, maxrpcsize: u32, ifcallback: ::windows::runtime::RawPtr, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12444         }
12445         ::std::mem::transmute(RpcServerRegisterIf3(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(mgrepv), ::std::mem::transmute(flags), ::std::mem::transmute(maxcalls), ::std::mem::transmute(maxrpcsize), ::std::mem::transmute(ifcallback), ::std::mem::transmute(securitydescriptor)))
12446     }
12447     #[cfg(not(windows))]
12448     unimplemented!("Unsupported target OS");
12449 }
12450 #[inline]
RpcServerRegisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, ifcallback: ::std::option::Option<RPC_IF_CALLBACK_FN>) -> RPC_STATUS12451 pub unsafe fn RpcServerRegisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, ifcallback: ::std::option::Option<RPC_IF_CALLBACK_FN>) -> RPC_STATUS {
12452     #[cfg(windows)]
12453     {
12454         #[link(name = "windows")]
12455         extern "system" {
12456             fn RpcServerRegisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, mgrepv: *const ::std::ffi::c_void, flags: u32, maxcalls: u32, ifcallback: ::windows::runtime::RawPtr) -> RPC_STATUS;
12457         }
12458         ::std::mem::transmute(RpcServerRegisterIfEx(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(mgrepv), ::std::mem::transmute(flags), ::std::mem::transmute(maxcalls), ::std::mem::transmute(ifcallback)))
12459     }
12460     #[cfg(not(windows))]
12461     unimplemented!("Unsupported target OS");
12462 }
12463 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
12464 #[inline]
RpcServerSubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationtype: RPC_NOTIFICATION_TYPES, notificationinfo: *const RPC_ASYNC_NOTIFICATION_INFO) -> RPC_STATUS12465 pub unsafe fn RpcServerSubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationtype: RPC_NOTIFICATION_TYPES, notificationinfo: *const RPC_ASYNC_NOTIFICATION_INFO) -> RPC_STATUS {
12466     #[cfg(windows)]
12467     {
12468         #[link(name = "windows")]
12469         extern "system" {
12470             fn RpcServerSubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationtype: RPC_NOTIFICATION_TYPES, notificationinfo: *const ::std::mem::ManuallyDrop<RPC_ASYNC_NOTIFICATION_INFO>) -> RPC_STATUS;
12471         }
12472         ::std::mem::transmute(RpcServerSubscribeForNotification(::std::mem::transmute(binding), ::std::mem::transmute(notification), ::std::mem::transmute(notificationtype), ::std::mem::transmute(notificationinfo)))
12473     }
12474     #[cfg(not(windows))]
12475     unimplemented!("Unsupported target OS");
12476 }
12477 #[inline]
RpcServerTestCancel(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS12478 pub unsafe fn RpcServerTestCancel(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS {
12479     #[cfg(windows)]
12480     {
12481         #[link(name = "windows")]
12482         extern "system" {
12483             fn RpcServerTestCancel(bindinghandle: *const ::std::ffi::c_void) -> RPC_STATUS;
12484         }
12485         ::std::mem::transmute(RpcServerTestCancel(::std::mem::transmute(bindinghandle)))
12486     }
12487     #[cfg(not(windows))]
12488     unimplemented!("Unsupported target OS");
12489 }
12490 #[inline]
RpcServerUnregisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, waitforcallstocomplete: u32) -> RPC_STATUS12491 pub unsafe fn RpcServerUnregisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, waitforcallstocomplete: u32) -> RPC_STATUS {
12492     #[cfg(windows)]
12493     {
12494         #[link(name = "windows")]
12495         extern "system" {
12496             fn RpcServerUnregisterIf(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, waitforcallstocomplete: u32) -> RPC_STATUS;
12497         }
12498         ::std::mem::transmute(RpcServerUnregisterIf(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(waitforcallstocomplete)))
12499     }
12500     #[cfg(not(windows))]
12501     unimplemented!("Unsupported target OS");
12502 }
12503 #[inline]
RpcServerUnregisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, rundowncontexthandles: i32) -> RPC_STATUS12504 pub unsafe fn RpcServerUnregisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, rundowncontexthandles: i32) -> RPC_STATUS {
12505     #[cfg(windows)]
12506     {
12507         #[link(name = "windows")]
12508         extern "system" {
12509             fn RpcServerUnregisterIfEx(ifspec: *const ::std::ffi::c_void, mgrtypeuuid: *const ::windows::runtime::GUID, rundowncontexthandles: i32) -> RPC_STATUS;
12510         }
12511         ::std::mem::transmute(RpcServerUnregisterIfEx(::std::mem::transmute(ifspec), ::std::mem::transmute(mgrtypeuuid), ::std::mem::transmute(rundowncontexthandles)))
12512     }
12513     #[cfg(not(windows))]
12514     unimplemented!("Unsupported target OS");
12515 }
12516 #[inline]
RpcServerUnsubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationsqueued: *mut u32) -> RPC_STATUS12517 pub unsafe fn RpcServerUnsubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationsqueued: *mut u32) -> RPC_STATUS {
12518     #[cfg(windows)]
12519     {
12520         #[link(name = "windows")]
12521         extern "system" {
12522             fn RpcServerUnsubscribeForNotification(binding: *const ::std::ffi::c_void, notification: RPC_NOTIFICATIONS, notificationsqueued: *mut u32) -> RPC_STATUS;
12523         }
12524         ::std::mem::transmute(RpcServerUnsubscribeForNotification(::std::mem::transmute(binding), ::std::mem::transmute(notification), ::std::mem::transmute(notificationsqueued)))
12525     }
12526     #[cfg(not(windows))]
12527     unimplemented!("Unsupported target OS");
12528 }
12529 #[inline]
RpcServerUseAllProtseqs(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12530 pub unsafe fn RpcServerUseAllProtseqs(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12531     #[cfg(windows)]
12532     {
12533         #[link(name = "windows")]
12534         extern "system" {
12535             fn RpcServerUseAllProtseqs(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12536         }
12537         ::std::mem::transmute(RpcServerUseAllProtseqs(::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor)))
12538     }
12539     #[cfg(not(windows))]
12540     unimplemented!("Unsupported target OS");
12541 }
12542 #[inline]
RpcServerUseAllProtseqsEx(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12543 pub unsafe fn RpcServerUseAllProtseqsEx(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12544     #[cfg(windows)]
12545     {
12546         #[link(name = "windows")]
12547         extern "system" {
12548             fn RpcServerUseAllProtseqsEx(maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12549         }
12550         ::std::mem::transmute(RpcServerUseAllProtseqsEx(::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12551     }
12552     #[cfg(not(windows))]
12553     unimplemented!("Unsupported target OS");
12554 }
12555 #[inline]
RpcServerUseAllProtseqsIf(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12556 pub unsafe fn RpcServerUseAllProtseqsIf(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12557     #[cfg(windows)]
12558     {
12559         #[link(name = "windows")]
12560         extern "system" {
12561             fn RpcServerUseAllProtseqsIf(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12562         }
12563         ::std::mem::transmute(RpcServerUseAllProtseqsIf(::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor)))
12564     }
12565     #[cfg(not(windows))]
12566     unimplemented!("Unsupported target OS");
12567 }
12568 #[inline]
RpcServerUseAllProtseqsIfEx(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12569 pub unsafe fn RpcServerUseAllProtseqsIfEx(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12570     #[cfg(windows)]
12571     {
12572         #[link(name = "windows")]
12573         extern "system" {
12574             fn RpcServerUseAllProtseqsIfEx(maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12575         }
12576         ::std::mem::transmute(RpcServerUseAllProtseqsIfEx(::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12577     }
12578     #[cfg(not(windows))]
12579     unimplemented!("Unsupported target OS");
12580 }
12581 #[inline]
RpcServerUseProtseqA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12582 pub unsafe fn RpcServerUseProtseqA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12583     #[cfg(windows)]
12584     {
12585         #[link(name = "windows")]
12586         extern "system" {
12587             fn RpcServerUseProtseqA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12588         }
12589         ::std::mem::transmute(RpcServerUseProtseqA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor)))
12590     }
12591     #[cfg(not(windows))]
12592     unimplemented!("Unsupported target OS");
12593 }
12594 #[inline]
RpcServerUseProtseqEpA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12595 pub unsafe fn RpcServerUseProtseqEpA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12596     #[cfg(windows)]
12597     {
12598         #[link(name = "windows")]
12599         extern "system" {
12600             fn RpcServerUseProtseqEpA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12601         }
12602         ::std::mem::transmute(RpcServerUseProtseqEpA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor)))
12603     }
12604     #[cfg(not(windows))]
12605     unimplemented!("Unsupported target OS");
12606 }
12607 #[inline]
RpcServerUseProtseqEpExA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12608 pub unsafe fn RpcServerUseProtseqEpExA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12609     #[cfg(windows)]
12610     {
12611         #[link(name = "windows")]
12612         extern "system" {
12613             fn RpcServerUseProtseqEpExA(protseq: *const u8, maxcalls: u32, endpoint: *const u8, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12614         }
12615         ::std::mem::transmute(RpcServerUseProtseqEpExA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12616     }
12617     #[cfg(not(windows))]
12618     unimplemented!("Unsupported target OS");
12619 }
12620 #[inline]
RpcServerUseProtseqEpExW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12621 pub unsafe fn RpcServerUseProtseqEpExW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12622     #[cfg(windows)]
12623     {
12624         #[link(name = "windows")]
12625         extern "system" {
12626             fn RpcServerUseProtseqEpExW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12627         }
12628         ::std::mem::transmute(RpcServerUseProtseqEpExW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12629     }
12630     #[cfg(not(windows))]
12631     unimplemented!("Unsupported target OS");
12632 }
12633 #[inline]
RpcServerUseProtseqEpW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12634 pub unsafe fn RpcServerUseProtseqEpW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12635     #[cfg(windows)]
12636     {
12637         #[link(name = "windows")]
12638         extern "system" {
12639             fn RpcServerUseProtseqEpW(protseq: *const u16, maxcalls: u32, endpoint: *const u16, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12640         }
12641         ::std::mem::transmute(RpcServerUseProtseqEpW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(endpoint), ::std::mem::transmute(securitydescriptor)))
12642     }
12643     #[cfg(not(windows))]
12644     unimplemented!("Unsupported target OS");
12645 }
12646 #[inline]
RpcServerUseProtseqExA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12647 pub unsafe fn RpcServerUseProtseqExA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12648     #[cfg(windows)]
12649     {
12650         #[link(name = "windows")]
12651         extern "system" {
12652             fn RpcServerUseProtseqExA(protseq: *const u8, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12653         }
12654         ::std::mem::transmute(RpcServerUseProtseqExA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12655     }
12656     #[cfg(not(windows))]
12657     unimplemented!("Unsupported target OS");
12658 }
12659 #[inline]
RpcServerUseProtseqExW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12660 pub unsafe fn RpcServerUseProtseqExW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12661     #[cfg(windows)]
12662     {
12663         #[link(name = "windows")]
12664         extern "system" {
12665             fn RpcServerUseProtseqExW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12666         }
12667         ::std::mem::transmute(RpcServerUseProtseqExW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12668     }
12669     #[cfg(not(windows))]
12670     unimplemented!("Unsupported target OS");
12671 }
12672 #[inline]
RpcServerUseProtseqIfA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12673 pub unsafe fn RpcServerUseProtseqIfA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12674     #[cfg(windows)]
12675     {
12676         #[link(name = "windows")]
12677         extern "system" {
12678             fn RpcServerUseProtseqIfA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12679         }
12680         ::std::mem::transmute(RpcServerUseProtseqIfA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor)))
12681     }
12682     #[cfg(not(windows))]
12683     unimplemented!("Unsupported target OS");
12684 }
12685 #[inline]
RpcServerUseProtseqIfExA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12686 pub unsafe fn RpcServerUseProtseqIfExA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12687     #[cfg(windows)]
12688     {
12689         #[link(name = "windows")]
12690         extern "system" {
12691             fn RpcServerUseProtseqIfExA(protseq: *const u8, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12692         }
12693         ::std::mem::transmute(RpcServerUseProtseqIfExA(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12694     }
12695     #[cfg(not(windows))]
12696     unimplemented!("Unsupported target OS");
12697 }
12698 #[inline]
RpcServerUseProtseqIfExW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS12699 pub unsafe fn RpcServerUseProtseqIfExW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS {
12700     #[cfg(windows)]
12701     {
12702         #[link(name = "windows")]
12703         extern "system" {
12704             fn RpcServerUseProtseqIfExW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void, policy: *const RPC_POLICY) -> RPC_STATUS;
12705         }
12706         ::std::mem::transmute(RpcServerUseProtseqIfExW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor), ::std::mem::transmute(policy)))
12707     }
12708     #[cfg(not(windows))]
12709     unimplemented!("Unsupported target OS");
12710 }
12711 #[inline]
RpcServerUseProtseqIfW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12712 pub unsafe fn RpcServerUseProtseqIfW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12713     #[cfg(windows)]
12714     {
12715         #[link(name = "windows")]
12716         extern "system" {
12717             fn RpcServerUseProtseqIfW(protseq: *const u16, maxcalls: u32, ifspec: *const ::std::ffi::c_void, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12718         }
12719         ::std::mem::transmute(RpcServerUseProtseqIfW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(ifspec), ::std::mem::transmute(securitydescriptor)))
12720     }
12721     #[cfg(not(windows))]
12722     unimplemented!("Unsupported target OS");
12723 }
12724 #[inline]
RpcServerUseProtseqW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS12725 pub unsafe fn RpcServerUseProtseqW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS {
12726     #[cfg(windows)]
12727     {
12728         #[link(name = "windows")]
12729         extern "system" {
12730             fn RpcServerUseProtseqW(protseq: *const u16, maxcalls: u32, securitydescriptor: *const ::std::ffi::c_void) -> RPC_STATUS;
12731         }
12732         ::std::mem::transmute(RpcServerUseProtseqW(::std::mem::transmute(protseq), ::std::mem::transmute(maxcalls), ::std::mem::transmute(securitydescriptor)))
12733     }
12734     #[cfg(not(windows))]
12735     unimplemented!("Unsupported target OS");
12736 }
12737 #[inline]
RpcServerYield()12738 pub unsafe fn RpcServerYield() {
12739     #[cfg(windows)]
12740     {
12741         #[link(name = "windows")]
12742         extern "system" {
12743             fn RpcServerYield();
12744         }
12745         ::std::mem::transmute(RpcServerYield())
12746     }
12747     #[cfg(not(windows))]
12748     unimplemented!("Unsupported target OS");
12749 }
12750 #[inline]
RpcSmAllocate(size: usize, pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void12751 pub unsafe fn RpcSmAllocate(size: usize, pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void {
12752     #[cfg(windows)]
12753     {
12754         #[link(name = "windows")]
12755         extern "system" {
12756             fn RpcSmAllocate(size: usize, pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void;
12757         }
12758         ::std::mem::transmute(RpcSmAllocate(::std::mem::transmute(size), ::std::mem::transmute(pstatus)))
12759     }
12760     #[cfg(not(windows))]
12761     unimplemented!("Unsupported target OS");
12762 }
12763 #[inline]
RpcSmClientFree(pnodetofree: *const ::std::ffi::c_void) -> RPC_STATUS12764 pub unsafe fn RpcSmClientFree(pnodetofree: *const ::std::ffi::c_void) -> RPC_STATUS {
12765     #[cfg(windows)]
12766     {
12767         #[link(name = "windows")]
12768         extern "system" {
12769             fn RpcSmClientFree(pnodetofree: *const ::std::ffi::c_void) -> RPC_STATUS;
12770         }
12771         ::std::mem::transmute(RpcSmClientFree(::std::mem::transmute(pnodetofree)))
12772     }
12773     #[cfg(not(windows))]
12774     unimplemented!("Unsupported target OS");
12775 }
12776 #[inline]
RpcSmDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void) -> RPC_STATUS12777 pub unsafe fn RpcSmDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void) -> RPC_STATUS {
12778     #[cfg(windows)]
12779     {
12780         #[link(name = "windows")]
12781         extern "system" {
12782             fn RpcSmDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void) -> RPC_STATUS;
12783         }
12784         ::std::mem::transmute(RpcSmDestroyClientContext(::std::mem::transmute(contexthandle)))
12785     }
12786     #[cfg(not(windows))]
12787     unimplemented!("Unsupported target OS");
12788 }
12789 #[inline]
RpcSmDisableAllocate() -> RPC_STATUS12790 pub unsafe fn RpcSmDisableAllocate() -> RPC_STATUS {
12791     #[cfg(windows)]
12792     {
12793         #[link(name = "windows")]
12794         extern "system" {
12795             fn RpcSmDisableAllocate() -> RPC_STATUS;
12796         }
12797         ::std::mem::transmute(RpcSmDisableAllocate())
12798     }
12799     #[cfg(not(windows))]
12800     unimplemented!("Unsupported target OS");
12801 }
12802 #[inline]
RpcSmEnableAllocate() -> RPC_STATUS12803 pub unsafe fn RpcSmEnableAllocate() -> RPC_STATUS {
12804     #[cfg(windows)]
12805     {
12806         #[link(name = "windows")]
12807         extern "system" {
12808             fn RpcSmEnableAllocate() -> RPC_STATUS;
12809         }
12810         ::std::mem::transmute(RpcSmEnableAllocate())
12811     }
12812     #[cfg(not(windows))]
12813     unimplemented!("Unsupported target OS");
12814 }
12815 #[inline]
RpcSmFree(nodetofree: *const ::std::ffi::c_void) -> RPC_STATUS12816 pub unsafe fn RpcSmFree(nodetofree: *const ::std::ffi::c_void) -> RPC_STATUS {
12817     #[cfg(windows)]
12818     {
12819         #[link(name = "windows")]
12820         extern "system" {
12821             fn RpcSmFree(nodetofree: *const ::std::ffi::c_void) -> RPC_STATUS;
12822         }
12823         ::std::mem::transmute(RpcSmFree(::std::mem::transmute(nodetofree)))
12824     }
12825     #[cfg(not(windows))]
12826     unimplemented!("Unsupported target OS");
12827 }
12828 #[inline]
RpcSmGetThreadHandle(pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void12829 pub unsafe fn RpcSmGetThreadHandle(pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void {
12830     #[cfg(windows)]
12831     {
12832         #[link(name = "windows")]
12833         extern "system" {
12834             fn RpcSmGetThreadHandle(pstatus: *mut RPC_STATUS) -> *mut ::std::ffi::c_void;
12835         }
12836         ::std::mem::transmute(RpcSmGetThreadHandle(::std::mem::transmute(pstatus)))
12837     }
12838     #[cfg(not(windows))]
12839     unimplemented!("Unsupported target OS");
12840 }
12841 #[inline]
RpcSmSetClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>) -> RPC_STATUS12842 pub unsafe fn RpcSmSetClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>) -> RPC_STATUS {
12843     #[cfg(windows)]
12844     {
12845         #[link(name = "windows")]
12846         extern "system" {
12847             fn RpcSmSetClientAllocFree(clientalloc: ::windows::runtime::RawPtr, clientfree: ::windows::runtime::RawPtr) -> RPC_STATUS;
12848         }
12849         ::std::mem::transmute(RpcSmSetClientAllocFree(::std::mem::transmute(clientalloc), ::std::mem::transmute(clientfree)))
12850     }
12851     #[cfg(not(windows))]
12852     unimplemented!("Unsupported target OS");
12853 }
12854 #[inline]
RpcSmSetThreadHandle(id: *const ::std::ffi::c_void) -> RPC_STATUS12855 pub unsafe fn RpcSmSetThreadHandle(id: *const ::std::ffi::c_void) -> RPC_STATUS {
12856     #[cfg(windows)]
12857     {
12858         #[link(name = "windows")]
12859         extern "system" {
12860             fn RpcSmSetThreadHandle(id: *const ::std::ffi::c_void) -> RPC_STATUS;
12861         }
12862         ::std::mem::transmute(RpcSmSetThreadHandle(::std::mem::transmute(id)))
12863     }
12864     #[cfg(not(windows))]
12865     unimplemented!("Unsupported target OS");
12866 }
12867 #[inline]
RpcSmSwapClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>, oldclientalloc: *mut ::std::option::Option<RPC_CLIENT_ALLOC>, oldclientfree: *mut ::std::option::Option<RPC_CLIENT_FREE>) -> RPC_STATUS12868 pub unsafe fn RpcSmSwapClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>, oldclientalloc: *mut ::std::option::Option<RPC_CLIENT_ALLOC>, oldclientfree: *mut ::std::option::Option<RPC_CLIENT_FREE>) -> RPC_STATUS {
12869     #[cfg(windows)]
12870     {
12871         #[link(name = "windows")]
12872         extern "system" {
12873             fn RpcSmSwapClientAllocFree(clientalloc: ::windows::runtime::RawPtr, clientfree: ::windows::runtime::RawPtr, oldclientalloc: *mut ::windows::runtime::RawPtr, oldclientfree: *mut ::windows::runtime::RawPtr) -> RPC_STATUS;
12874         }
12875         ::std::mem::transmute(RpcSmSwapClientAllocFree(::std::mem::transmute(clientalloc), ::std::mem::transmute(clientfree), ::std::mem::transmute(oldclientalloc), ::std::mem::transmute(oldclientfree)))
12876     }
12877     #[cfg(not(windows))]
12878     unimplemented!("Unsupported target OS");
12879 }
12880 #[inline]
RpcSsAllocate(size: usize) -> *mut ::std::ffi::c_void12881 pub unsafe fn RpcSsAllocate(size: usize) -> *mut ::std::ffi::c_void {
12882     #[cfg(windows)]
12883     {
12884         #[link(name = "windows")]
12885         extern "system" {
12886             fn RpcSsAllocate(size: usize) -> *mut ::std::ffi::c_void;
12887         }
12888         ::std::mem::transmute(RpcSsAllocate(::std::mem::transmute(size)))
12889     }
12890     #[cfg(not(windows))]
12891     unimplemented!("Unsupported target OS");
12892 }
12893 #[inline]
RpcSsContextLockExclusive(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS12894 pub unsafe fn RpcSsContextLockExclusive(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS {
12895     #[cfg(windows)]
12896     {
12897         #[link(name = "windows")]
12898         extern "system" {
12899             fn RpcSsContextLockExclusive(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS;
12900         }
12901         ::std::mem::transmute(RpcSsContextLockExclusive(::std::mem::transmute(serverbindinghandle), ::std::mem::transmute(usercontext)))
12902     }
12903     #[cfg(not(windows))]
12904     unimplemented!("Unsupported target OS");
12905 }
12906 #[inline]
RpcSsContextLockShared(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS12907 pub unsafe fn RpcSsContextLockShared(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS {
12908     #[cfg(windows)]
12909     {
12910         #[link(name = "windows")]
12911         extern "system" {
12912             fn RpcSsContextLockShared(serverbindinghandle: *const ::std::ffi::c_void, usercontext: *const ::std::ffi::c_void) -> RPC_STATUS;
12913         }
12914         ::std::mem::transmute(RpcSsContextLockShared(::std::mem::transmute(serverbindinghandle), ::std::mem::transmute(usercontext)))
12915     }
12916     #[cfg(not(windows))]
12917     unimplemented!("Unsupported target OS");
12918 }
12919 #[inline]
RpcSsDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void)12920 pub unsafe fn RpcSsDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void) {
12921     #[cfg(windows)]
12922     {
12923         #[link(name = "windows")]
12924         extern "system" {
12925             fn RpcSsDestroyClientContext(contexthandle: *const *const ::std::ffi::c_void);
12926         }
12927         ::std::mem::transmute(RpcSsDestroyClientContext(::std::mem::transmute(contexthandle)))
12928     }
12929     #[cfg(not(windows))]
12930     unimplemented!("Unsupported target OS");
12931 }
12932 #[inline]
RpcSsDisableAllocate()12933 pub unsafe fn RpcSsDisableAllocate() {
12934     #[cfg(windows)]
12935     {
12936         #[link(name = "windows")]
12937         extern "system" {
12938             fn RpcSsDisableAllocate();
12939         }
12940         ::std::mem::transmute(RpcSsDisableAllocate())
12941     }
12942     #[cfg(not(windows))]
12943     unimplemented!("Unsupported target OS");
12944 }
12945 #[inline]
RpcSsDontSerializeContext()12946 pub unsafe fn RpcSsDontSerializeContext() {
12947     #[cfg(windows)]
12948     {
12949         #[link(name = "windows")]
12950         extern "system" {
12951             fn RpcSsDontSerializeContext();
12952         }
12953         ::std::mem::transmute(RpcSsDontSerializeContext())
12954     }
12955     #[cfg(not(windows))]
12956     unimplemented!("Unsupported target OS");
12957 }
12958 #[inline]
RpcSsEnableAllocate()12959 pub unsafe fn RpcSsEnableAllocate() {
12960     #[cfg(windows)]
12961     {
12962         #[link(name = "windows")]
12963         extern "system" {
12964             fn RpcSsEnableAllocate();
12965         }
12966         ::std::mem::transmute(RpcSsEnableAllocate())
12967     }
12968     #[cfg(not(windows))]
12969     unimplemented!("Unsupported target OS");
12970 }
12971 #[inline]
RpcSsFree(nodetofree: *const ::std::ffi::c_void)12972 pub unsafe fn RpcSsFree(nodetofree: *const ::std::ffi::c_void) {
12973     #[cfg(windows)]
12974     {
12975         #[link(name = "windows")]
12976         extern "system" {
12977             fn RpcSsFree(nodetofree: *const ::std::ffi::c_void);
12978         }
12979         ::std::mem::transmute(RpcSsFree(::std::mem::transmute(nodetofree)))
12980     }
12981     #[cfg(not(windows))]
12982     unimplemented!("Unsupported target OS");
12983 }
12984 #[inline]
RpcSsGetContextBinding(contexthandle: *const ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS12985 pub unsafe fn RpcSsGetContextBinding(contexthandle: *const ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS {
12986     #[cfg(windows)]
12987     {
12988         #[link(name = "windows")]
12989         extern "system" {
12990             fn RpcSsGetContextBinding(contexthandle: *const ::std::ffi::c_void, binding: *mut *mut ::std::ffi::c_void) -> RPC_STATUS;
12991         }
12992         ::std::mem::transmute(RpcSsGetContextBinding(::std::mem::transmute(contexthandle), ::std::mem::transmute(binding)))
12993     }
12994     #[cfg(not(windows))]
12995     unimplemented!("Unsupported target OS");
12996 }
12997 #[inline]
RpcSsGetThreadHandle() -> *mut ::std::ffi::c_void12998 pub unsafe fn RpcSsGetThreadHandle() -> *mut ::std::ffi::c_void {
12999     #[cfg(windows)]
13000     {
13001         #[link(name = "windows")]
13002         extern "system" {
13003             fn RpcSsGetThreadHandle() -> *mut ::std::ffi::c_void;
13004         }
13005         ::std::mem::transmute(RpcSsGetThreadHandle())
13006     }
13007     #[cfg(not(windows))]
13008     unimplemented!("Unsupported target OS");
13009 }
13010 #[inline]
RpcSsSetClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>)13011 pub unsafe fn RpcSsSetClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>) {
13012     #[cfg(windows)]
13013     {
13014         #[link(name = "windows")]
13015         extern "system" {
13016             fn RpcSsSetClientAllocFree(clientalloc: ::windows::runtime::RawPtr, clientfree: ::windows::runtime::RawPtr);
13017         }
13018         ::std::mem::transmute(RpcSsSetClientAllocFree(::std::mem::transmute(clientalloc), ::std::mem::transmute(clientfree)))
13019     }
13020     #[cfg(not(windows))]
13021     unimplemented!("Unsupported target OS");
13022 }
13023 #[inline]
RpcSsSetThreadHandle(id: *const ::std::ffi::c_void)13024 pub unsafe fn RpcSsSetThreadHandle(id: *const ::std::ffi::c_void) {
13025     #[cfg(windows)]
13026     {
13027         #[link(name = "windows")]
13028         extern "system" {
13029             fn RpcSsSetThreadHandle(id: *const ::std::ffi::c_void);
13030         }
13031         ::std::mem::transmute(RpcSsSetThreadHandle(::std::mem::transmute(id)))
13032     }
13033     #[cfg(not(windows))]
13034     unimplemented!("Unsupported target OS");
13035 }
13036 #[inline]
RpcSsSwapClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>, oldclientalloc: *mut ::std::option::Option<RPC_CLIENT_ALLOC>, oldclientfree: *mut ::std::option::Option<RPC_CLIENT_FREE>)13037 pub unsafe fn RpcSsSwapClientAllocFree(clientalloc: ::std::option::Option<RPC_CLIENT_ALLOC>, clientfree: ::std::option::Option<RPC_CLIENT_FREE>, oldclientalloc: *mut ::std::option::Option<RPC_CLIENT_ALLOC>, oldclientfree: *mut ::std::option::Option<RPC_CLIENT_FREE>) {
13038     #[cfg(windows)]
13039     {
13040         #[link(name = "windows")]
13041         extern "system" {
13042             fn RpcSsSwapClientAllocFree(clientalloc: ::windows::runtime::RawPtr, clientfree: ::windows::runtime::RawPtr, oldclientalloc: *mut ::windows::runtime::RawPtr, oldclientfree: *mut ::windows::runtime::RawPtr);
13043         }
13044         ::std::mem::transmute(RpcSsSwapClientAllocFree(::std::mem::transmute(clientalloc), ::std::mem::transmute(clientfree), ::std::mem::transmute(oldclientalloc), ::std::mem::transmute(oldclientfree)))
13045     }
13046     #[cfg(not(windows))]
13047     unimplemented!("Unsupported target OS");
13048 }
13049 #[inline]
RpcStringBindingComposeA(objuuid: *const u8, protseq: *const u8, networkaddr: *const u8, endpoint: *const u8, options: *const u8, stringbinding: *mut *mut u8) -> RPC_STATUS13050 pub unsafe fn RpcStringBindingComposeA(objuuid: *const u8, protseq: *const u8, networkaddr: *const u8, endpoint: *const u8, options: *const u8, stringbinding: *mut *mut u8) -> RPC_STATUS {
13051     #[cfg(windows)]
13052     {
13053         #[link(name = "windows")]
13054         extern "system" {
13055             fn RpcStringBindingComposeA(objuuid: *const u8, protseq: *const u8, networkaddr: *const u8, endpoint: *const u8, options: *const u8, stringbinding: *mut *mut u8) -> RPC_STATUS;
13056         }
13057         ::std::mem::transmute(RpcStringBindingComposeA(::std::mem::transmute(objuuid), ::std::mem::transmute(protseq), ::std::mem::transmute(networkaddr), ::std::mem::transmute(endpoint), ::std::mem::transmute(options), ::std::mem::transmute(stringbinding)))
13058     }
13059     #[cfg(not(windows))]
13060     unimplemented!("Unsupported target OS");
13061 }
13062 #[inline]
RpcStringBindingComposeW(objuuid: *const u16, protseq: *const u16, networkaddr: *const u16, endpoint: *const u16, options: *const u16, stringbinding: *mut *mut u16) -> RPC_STATUS13063 pub unsafe fn RpcStringBindingComposeW(objuuid: *const u16, protseq: *const u16, networkaddr: *const u16, endpoint: *const u16, options: *const u16, stringbinding: *mut *mut u16) -> RPC_STATUS {
13064     #[cfg(windows)]
13065     {
13066         #[link(name = "windows")]
13067         extern "system" {
13068             fn RpcStringBindingComposeW(objuuid: *const u16, protseq: *const u16, networkaddr: *const u16, endpoint: *const u16, options: *const u16, stringbinding: *mut *mut u16) -> RPC_STATUS;
13069         }
13070         ::std::mem::transmute(RpcStringBindingComposeW(::std::mem::transmute(objuuid), ::std::mem::transmute(protseq), ::std::mem::transmute(networkaddr), ::std::mem::transmute(endpoint), ::std::mem::transmute(options), ::std::mem::transmute(stringbinding)))
13071     }
13072     #[cfg(not(windows))]
13073     unimplemented!("Unsupported target OS");
13074 }
13075 #[inline]
RpcStringBindingParseA(stringbinding: *const u8, objuuid: *mut *mut u8, protseq: *mut *mut u8, networkaddr: *mut *mut u8, endpoint: *mut *mut u8, networkoptions: *mut *mut u8) -> RPC_STATUS13076 pub unsafe fn RpcStringBindingParseA(stringbinding: *const u8, objuuid: *mut *mut u8, protseq: *mut *mut u8, networkaddr: *mut *mut u8, endpoint: *mut *mut u8, networkoptions: *mut *mut u8) -> RPC_STATUS {
13077     #[cfg(windows)]
13078     {
13079         #[link(name = "windows")]
13080         extern "system" {
13081             fn RpcStringBindingParseA(stringbinding: *const u8, objuuid: *mut *mut u8, protseq: *mut *mut u8, networkaddr: *mut *mut u8, endpoint: *mut *mut u8, networkoptions: *mut *mut u8) -> RPC_STATUS;
13082         }
13083         ::std::mem::transmute(RpcStringBindingParseA(::std::mem::transmute(stringbinding), ::std::mem::transmute(objuuid), ::std::mem::transmute(protseq), ::std::mem::transmute(networkaddr), ::std::mem::transmute(endpoint), ::std::mem::transmute(networkoptions)))
13084     }
13085     #[cfg(not(windows))]
13086     unimplemented!("Unsupported target OS");
13087 }
13088 #[inline]
RpcStringBindingParseW(stringbinding: *const u16, objuuid: *mut *mut u16, protseq: *mut *mut u16, networkaddr: *mut *mut u16, endpoint: *mut *mut u16, networkoptions: *mut *mut u16) -> RPC_STATUS13089 pub unsafe fn RpcStringBindingParseW(stringbinding: *const u16, objuuid: *mut *mut u16, protseq: *mut *mut u16, networkaddr: *mut *mut u16, endpoint: *mut *mut u16, networkoptions: *mut *mut u16) -> RPC_STATUS {
13090     #[cfg(windows)]
13091     {
13092         #[link(name = "windows")]
13093         extern "system" {
13094             fn RpcStringBindingParseW(stringbinding: *const u16, objuuid: *mut *mut u16, protseq: *mut *mut u16, networkaddr: *mut *mut u16, endpoint: *mut *mut u16, networkoptions: *mut *mut u16) -> RPC_STATUS;
13095         }
13096         ::std::mem::transmute(RpcStringBindingParseW(::std::mem::transmute(stringbinding), ::std::mem::transmute(objuuid), ::std::mem::transmute(protseq), ::std::mem::transmute(networkaddr), ::std::mem::transmute(endpoint), ::std::mem::transmute(networkoptions)))
13097     }
13098     #[cfg(not(windows))]
13099     unimplemented!("Unsupported target OS");
13100 }
13101 #[inline]
RpcStringFreeA(string: *mut *mut u8) -> RPC_STATUS13102 pub unsafe fn RpcStringFreeA(string: *mut *mut u8) -> RPC_STATUS {
13103     #[cfg(windows)]
13104     {
13105         #[link(name = "windows")]
13106         extern "system" {
13107             fn RpcStringFreeA(string: *mut *mut u8) -> RPC_STATUS;
13108         }
13109         ::std::mem::transmute(RpcStringFreeA(::std::mem::transmute(string)))
13110     }
13111     #[cfg(not(windows))]
13112     unimplemented!("Unsupported target OS");
13113 }
13114 #[inline]
RpcStringFreeW(string: *mut *mut u16) -> RPC_STATUS13115 pub unsafe fn RpcStringFreeW(string: *mut *mut u16) -> RPC_STATUS {
13116     #[cfg(windows)]
13117     {
13118         #[link(name = "windows")]
13119         extern "system" {
13120             fn RpcStringFreeW(string: *mut *mut u16) -> RPC_STATUS;
13121         }
13122         ::std::mem::transmute(RpcStringFreeW(::std::mem::transmute(string)))
13123     }
13124     #[cfg(not(windows))]
13125     unimplemented!("Unsupported target OS");
13126 }
13127 #[inline]
RpcTestCancel() -> RPC_STATUS13128 pub unsafe fn RpcTestCancel() -> RPC_STATUS {
13129     #[cfg(windows)]
13130     {
13131         #[link(name = "windows")]
13132         extern "system" {
13133             fn RpcTestCancel() -> RPC_STATUS;
13134         }
13135         ::std::mem::transmute(RpcTestCancel())
13136     }
13137     #[cfg(not(windows))]
13138     unimplemented!("Unsupported target OS");
13139 }
13140 #[inline]
RpcUserFree(asynchandle: *mut ::std::ffi::c_void, pbuffer: *mut ::std::ffi::c_void)13141 pub unsafe fn RpcUserFree(asynchandle: *mut ::std::ffi::c_void, pbuffer: *mut ::std::ffi::c_void) {
13142     #[cfg(windows)]
13143     {
13144         #[link(name = "windows")]
13145         extern "system" {
13146             fn RpcUserFree(asynchandle: *mut ::std::ffi::c_void, pbuffer: *mut ::std::ffi::c_void);
13147         }
13148         ::std::mem::transmute(RpcUserFree(::std::mem::transmute(asynchandle), ::std::mem::transmute(pbuffer)))
13149     }
13150     #[cfg(not(windows))]
13151     unimplemented!("Unsupported target OS");
13152 }
13153 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13154 #[repr(C)]
13155 pub struct SCONTEXT_QUEUE {
13156     pub NumberOfObjects: u32,
13157     pub ArrayOfObjects: *mut *mut NDR_SCONTEXT_1,
13158 }
13159 impl SCONTEXT_QUEUE {}
13160 impl ::std::default::Default for SCONTEXT_QUEUE {
default() -> Self13161     fn default() -> Self {
13162         unsafe { ::std::mem::zeroed() }
13163     }
13164 }
13165 impl ::std::fmt::Debug for SCONTEXT_QUEUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13166     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13167         fmt.debug_struct("SCONTEXT_QUEUE").field("NumberOfObjects", &self.NumberOfObjects).field("ArrayOfObjects", &self.ArrayOfObjects).finish()
13168     }
13169 }
13170 impl ::std::cmp::PartialEq for SCONTEXT_QUEUE {
eq(&self, other: &Self) -> bool13171     fn eq(&self, other: &Self) -> bool {
13172         self.NumberOfObjects == other.NumberOfObjects && self.ArrayOfObjects == other.ArrayOfObjects
13173     }
13174 }
13175 impl ::std::cmp::Eq for SCONTEXT_QUEUE {}
13176 unsafe impl ::windows::runtime::Abi for SCONTEXT_QUEUE {
13177     type Abi = Self;
13178     type DefaultType = Self;
13179 }
13180 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13181 #[repr(transparent)]
13182 pub struct SEC_WINNT_AUTH_IDENTITY(pub u32);
13183 pub const SEC_WINNT_AUTH_IDENTITY_ANSI: SEC_WINNT_AUTH_IDENTITY = SEC_WINNT_AUTH_IDENTITY(1u32);
13184 pub const SEC_WINNT_AUTH_IDENTITY_UNICODE: SEC_WINNT_AUTH_IDENTITY = SEC_WINNT_AUTH_IDENTITY(2u32);
13185 impl ::std::convert::From<u32> for SEC_WINNT_AUTH_IDENTITY {
from(value: u32) -> Self13186     fn from(value: u32) -> Self {
13187         Self(value)
13188     }
13189 }
13190 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY {
13191     type Abi = Self;
13192     type DefaultType = Self;
13193 }
13194 impl ::std::ops::BitOr for SEC_WINNT_AUTH_IDENTITY {
13195     type Output = Self;
bitor(self, rhs: Self) -> Self13196     fn bitor(self, rhs: Self) -> Self {
13197         Self(self.0 | rhs.0)
13198     }
13199 }
13200 impl ::std::ops::BitAnd for SEC_WINNT_AUTH_IDENTITY {
13201     type Output = Self;
bitand(self, rhs: Self) -> Self13202     fn bitand(self, rhs: Self) -> Self {
13203         Self(self.0 & rhs.0)
13204     }
13205 }
13206 impl ::std::ops::BitOrAssign for SEC_WINNT_AUTH_IDENTITY {
bitor_assign(&mut self, rhs: Self)13207     fn bitor_assign(&mut self, rhs: Self) {
13208         self.0.bitor_assign(rhs.0)
13209     }
13210 }
13211 impl ::std::ops::BitAndAssign for SEC_WINNT_AUTH_IDENTITY {
bitand_assign(&mut self, rhs: Self)13212     fn bitand_assign(&mut self, rhs: Self) {
13213         self.0.bitand_assign(rhs.0)
13214     }
13215 }
13216 impl ::std::ops::Not for SEC_WINNT_AUTH_IDENTITY {
13217     type Output = Self;
not(self) -> Self13218     fn not(self) -> Self {
13219         Self(self.0.not())
13220     }
13221 }
13222 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13223 #[repr(C)]
13224 pub struct SEC_WINNT_AUTH_IDENTITY_A {
13225     pub User: *mut u8,
13226     pub UserLength: u32,
13227     pub Domain: *mut u8,
13228     pub DomainLength: u32,
13229     pub Password: *mut u8,
13230     pub PasswordLength: u32,
13231     pub Flags: SEC_WINNT_AUTH_IDENTITY,
13232 }
13233 impl SEC_WINNT_AUTH_IDENTITY_A {}
13234 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_A {
default() -> Self13235     fn default() -> Self {
13236         unsafe { ::std::mem::zeroed() }
13237     }
13238 }
13239 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13240     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13241         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_A").field("User", &self.User).field("UserLength", &self.UserLength).field("Domain", &self.Domain).field("DomainLength", &self.DomainLength).field("Password", &self.Password).field("PasswordLength", &self.PasswordLength).field("Flags", &self.Flags).finish()
13242     }
13243 }
13244 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_A {
eq(&self, other: &Self) -> bool13245     fn eq(&self, other: &Self) -> bool {
13246         self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags
13247     }
13248 }
13249 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_A {}
13250 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_A {
13251     type Abi = Self;
13252     type DefaultType = Self;
13253 }
13254 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13255 #[repr(C)]
13256 pub struct SEC_WINNT_AUTH_IDENTITY_W {
13257     pub User: *mut u16,
13258     pub UserLength: u32,
13259     pub Domain: *mut u16,
13260     pub DomainLength: u32,
13261     pub Password: *mut u16,
13262     pub PasswordLength: u32,
13263     pub Flags: SEC_WINNT_AUTH_IDENTITY,
13264 }
13265 impl SEC_WINNT_AUTH_IDENTITY_W {}
13266 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_W {
default() -> Self13267     fn default() -> Self {
13268         unsafe { ::std::mem::zeroed() }
13269     }
13270 }
13271 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13272     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13273         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_W").field("User", &self.User).field("UserLength", &self.UserLength).field("Domain", &self.Domain).field("DomainLength", &self.DomainLength).field("Password", &self.Password).field("PasswordLength", &self.PasswordLength).field("Flags", &self.Flags).finish()
13274     }
13275 }
13276 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_W {
eq(&self, other: &Self) -> bool13277     fn eq(&self, other: &Self) -> bool {
13278         self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags
13279     }
13280 }
13281 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_W {}
13282 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_W {
13283     type Abi = Self;
13284     type DefaultType = Self;
13285 }
13286 pub type SERVER_ROUTINE = unsafe extern "system" fn() -> i32;
13287 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13288 #[repr(transparent)]
13289 pub struct STUB_PHASE(pub i32);
13290 pub const STUB_UNMARSHAL: STUB_PHASE = STUB_PHASE(0i32);
13291 pub const STUB_CALL_SERVER: STUB_PHASE = STUB_PHASE(1i32);
13292 pub const STUB_MARSHAL: STUB_PHASE = STUB_PHASE(2i32);
13293 pub const STUB_CALL_SERVER_NO_HRESULT: STUB_PHASE = STUB_PHASE(3i32);
13294 impl ::std::convert::From<i32> for STUB_PHASE {
from(value: i32) -> Self13295     fn from(value: i32) -> Self {
13296         Self(value)
13297     }
13298 }
13299 unsafe impl ::windows::runtime::Abi for STUB_PHASE {
13300     type Abi = Self;
13301     type DefaultType = Self;
13302 }
13303 #[cfg(feature = "Win32_System_Com")]
13304 pub type STUB_THUNK = unsafe extern "system" fn(param0: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
13305 pub const TARGET_IS_NT100_OR_LATER: u32 = 1u32;
13306 pub const TARGET_IS_NT351_OR_WIN95_OR_LATER: u32 = 1u32;
13307 pub const TARGET_IS_NT40_OR_LATER: u32 = 1u32;
13308 pub const TARGET_IS_NT50_OR_LATER: u32 = 1u32;
13309 pub const TARGET_IS_NT51_OR_LATER: u32 = 1u32;
13310 pub const TARGET_IS_NT60_OR_LATER: u32 = 1u32;
13311 pub const TARGET_IS_NT61_OR_LATER: u32 = 1u32;
13312 pub const TARGET_IS_NT62_OR_LATER: u32 = 1u32;
13313 pub const TARGET_IS_NT63_OR_LATER: u32 = 1u32;
13314 pub const TRANSPORT_TYPE_CN: u32 = 1u32;
13315 pub const TRANSPORT_TYPE_DG: u32 = 2u32;
13316 pub const TRANSPORT_TYPE_LPC: u32 = 4u32;
13317 pub const TRANSPORT_TYPE_WMSG: u32 = 8u32;
13318 pub const USER_CALL_IS_ASYNC: u32 = 256u32;
13319 pub const USER_CALL_NEW_CORRELATION_DESC: u32 = 512u32;
13320 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13321 #[repr(C)]
13322 #[cfg(feature = "Win32_System_Com")]
13323 pub struct USER_MARSHAL_CB {
13324     pub Flags: u32,
13325     pub pStubMsg: *mut MIDL_STUB_MESSAGE,
13326     pub pReserve: *mut u8,
13327     pub Signature: u32,
13328     pub CBType: USER_MARSHAL_CB_TYPE,
13329     pub pFormat: *mut u8,
13330     pub pTypeFormat: *mut u8,
13331 }
13332 #[cfg(feature = "Win32_System_Com")]
13333 impl USER_MARSHAL_CB {}
13334 #[cfg(feature = "Win32_System_Com")]
13335 impl ::std::default::Default for USER_MARSHAL_CB {
default() -> Self13336     fn default() -> Self {
13337         unsafe { ::std::mem::zeroed() }
13338     }
13339 }
13340 #[cfg(feature = "Win32_System_Com")]
13341 impl ::std::fmt::Debug for USER_MARSHAL_CB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13342     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13343         fmt.debug_struct("USER_MARSHAL_CB").field("Flags", &self.Flags).field("pStubMsg", &self.pStubMsg).field("pReserve", &self.pReserve).field("Signature", &self.Signature).field("CBType", &self.CBType).field("pFormat", &self.pFormat).field("pTypeFormat", &self.pTypeFormat).finish()
13344     }
13345 }
13346 #[cfg(feature = "Win32_System_Com")]
13347 impl ::std::cmp::PartialEq for USER_MARSHAL_CB {
eq(&self, other: &Self) -> bool13348     fn eq(&self, other: &Self) -> bool {
13349         self.Flags == other.Flags && self.pStubMsg == other.pStubMsg && self.pReserve == other.pReserve && self.Signature == other.Signature && self.CBType == other.CBType && self.pFormat == other.pFormat && self.pTypeFormat == other.pTypeFormat
13350     }
13351 }
13352 #[cfg(feature = "Win32_System_Com")]
13353 impl ::std::cmp::Eq for USER_MARSHAL_CB {}
13354 #[cfg(feature = "Win32_System_Com")]
13355 unsafe impl ::windows::runtime::Abi for USER_MARSHAL_CB {
13356     type Abi = Self;
13357     type DefaultType = Self;
13358 }
13359 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13360 #[repr(transparent)]
13361 pub struct USER_MARSHAL_CB_TYPE(pub i32);
13362 pub const USER_MARSHAL_CB_BUFFER_SIZE: USER_MARSHAL_CB_TYPE = USER_MARSHAL_CB_TYPE(0i32);
13363 pub const USER_MARSHAL_CB_MARSHALL: USER_MARSHAL_CB_TYPE = USER_MARSHAL_CB_TYPE(1i32);
13364 pub const USER_MARSHAL_CB_UNMARSHALL: USER_MARSHAL_CB_TYPE = USER_MARSHAL_CB_TYPE(2i32);
13365 pub const USER_MARSHAL_CB_FREE: USER_MARSHAL_CB_TYPE = USER_MARSHAL_CB_TYPE(3i32);
13366 impl ::std::convert::From<i32> for USER_MARSHAL_CB_TYPE {
from(value: i32) -> Self13367     fn from(value: i32) -> Self {
13368         Self(value)
13369     }
13370 }
13371 unsafe impl ::windows::runtime::Abi for USER_MARSHAL_CB_TYPE {
13372     type Abi = Self;
13373     type DefaultType = Self;
13374 }
13375 pub const USER_MARSHAL_FC_BYTE: u32 = 1u32;
13376 pub const USER_MARSHAL_FC_CHAR: u32 = 2u32;
13377 pub const USER_MARSHAL_FC_DOUBLE: u32 = 12u32;
13378 pub const USER_MARSHAL_FC_FLOAT: u32 = 10u32;
13379 pub const USER_MARSHAL_FC_HYPER: u32 = 11u32;
13380 pub const USER_MARSHAL_FC_LONG: u32 = 8u32;
13381 pub const USER_MARSHAL_FC_SHORT: u32 = 6u32;
13382 pub const USER_MARSHAL_FC_SMALL: u32 = 3u32;
13383 pub const USER_MARSHAL_FC_ULONG: u32 = 9u32;
13384 pub const USER_MARSHAL_FC_USHORT: u32 = 7u32;
13385 pub const USER_MARSHAL_FC_USMALL: u32 = 4u32;
13386 pub const USER_MARSHAL_FC_WCHAR: u32 = 5u32;
13387 pub type USER_MARSHAL_FREEING_ROUTINE = unsafe extern "system" fn(param0: *mut u32, param1: *mut ::std::ffi::c_void);
13388 pub type USER_MARSHAL_MARSHALLING_ROUTINE = unsafe extern "system" fn(param0: *mut u32, param1: *mut u8, param2: *mut ::std::ffi::c_void) -> *mut u8;
13389 #[derive(:: std :: clone :: Clone)]
13390 #[repr(C)]
13391 pub struct USER_MARSHAL_ROUTINE_QUADRUPLE {
13392     pub pfnBufferSize: ::std::option::Option<USER_MARSHAL_SIZING_ROUTINE>,
13393     pub pfnMarshall: ::std::option::Option<USER_MARSHAL_MARSHALLING_ROUTINE>,
13394     pub pfnUnmarshall: ::std::option::Option<USER_MARSHAL_UNMARSHALLING_ROUTINE>,
13395     pub pfnFree: ::std::option::Option<USER_MARSHAL_FREEING_ROUTINE>,
13396 }
13397 impl USER_MARSHAL_ROUTINE_QUADRUPLE {}
13398 impl ::std::default::Default for USER_MARSHAL_ROUTINE_QUADRUPLE {
default() -> Self13399     fn default() -> Self {
13400         unsafe { ::std::mem::zeroed() }
13401     }
13402 }
13403 impl ::std::fmt::Debug for USER_MARSHAL_ROUTINE_QUADRUPLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13404     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13405         fmt.debug_struct("USER_MARSHAL_ROUTINE_QUADRUPLE").finish()
13406     }
13407 }
13408 impl ::std::cmp::PartialEq for USER_MARSHAL_ROUTINE_QUADRUPLE {
eq(&self, other: &Self) -> bool13409     fn eq(&self, other: &Self) -> bool {
13410         self.pfnBufferSize.map(|f| f as usize) == other.pfnBufferSize.map(|f| f as usize) && self.pfnMarshall.map(|f| f as usize) == other.pfnMarshall.map(|f| f as usize) && self.pfnUnmarshall.map(|f| f as usize) == other.pfnUnmarshall.map(|f| f as usize) && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
13411     }
13412 }
13413 impl ::std::cmp::Eq for USER_MARSHAL_ROUTINE_QUADRUPLE {}
13414 unsafe impl ::windows::runtime::Abi for USER_MARSHAL_ROUTINE_QUADRUPLE {
13415     type Abi = ::std::mem::ManuallyDrop<Self>;
13416     type DefaultType = Self;
13417 }
13418 pub type USER_MARSHAL_SIZING_ROUTINE = unsafe extern "system" fn(param0: *mut u32, param1: u32, param2: *mut ::std::ffi::c_void) -> u32;
13419 pub type USER_MARSHAL_UNMARSHALLING_ROUTINE = unsafe extern "system" fn(param0: *mut u32, param1: *mut u8, param2: *mut ::std::ffi::c_void) -> *mut u8;
13420 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13421 #[repr(C)]
13422 pub struct UUID_VECTOR {
13423     pub Count: u32,
13424     pub Uuid: [*mut ::windows::runtime::GUID; 1],
13425 }
13426 impl UUID_VECTOR {}
13427 impl ::std::default::Default for UUID_VECTOR {
default() -> Self13428     fn default() -> Self {
13429         unsafe { ::std::mem::zeroed() }
13430     }
13431 }
13432 impl ::std::fmt::Debug for UUID_VECTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13433     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13434         fmt.debug_struct("UUID_VECTOR").field("Count", &self.Count).field("Uuid", &self.Uuid).finish()
13435     }
13436 }
13437 impl ::std::cmp::PartialEq for UUID_VECTOR {
eq(&self, other: &Self) -> bool13438     fn eq(&self, other: &Self) -> bool {
13439         self.Count == other.Count && self.Uuid == other.Uuid
13440     }
13441 }
13442 impl ::std::cmp::Eq for UUID_VECTOR {}
13443 unsafe impl ::windows::runtime::Abi for UUID_VECTOR {
13444     type Abi = Self;
13445     type DefaultType = Self;
13446 }
13447 #[inline]
UuidCompare(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i3213448 pub unsafe fn UuidCompare(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32 {
13449     #[cfg(windows)]
13450     {
13451         #[link(name = "windows")]
13452         extern "system" {
13453             fn UuidCompare(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32;
13454         }
13455         ::std::mem::transmute(UuidCompare(::std::mem::transmute(uuid1), ::std::mem::transmute(uuid2), ::std::mem::transmute(status)))
13456     }
13457     #[cfg(not(windows))]
13458     unimplemented!("Unsupported target OS");
13459 }
13460 #[inline]
UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS13461 pub unsafe fn UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
13462     #[cfg(windows)]
13463     {
13464         #[link(name = "windows")]
13465         extern "system" {
13466             fn UuidCreate(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
13467         }
13468         ::std::mem::transmute(UuidCreate(::std::mem::transmute(uuid)))
13469     }
13470     #[cfg(not(windows))]
13471     unimplemented!("Unsupported target OS");
13472 }
13473 #[inline]
UuidCreateNil(niluuid: *mut ::windows::runtime::GUID) -> RPC_STATUS13474 pub unsafe fn UuidCreateNil(niluuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
13475     #[cfg(windows)]
13476     {
13477         #[link(name = "windows")]
13478         extern "system" {
13479             fn UuidCreateNil(niluuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
13480         }
13481         ::std::mem::transmute(UuidCreateNil(::std::mem::transmute(niluuid)))
13482     }
13483     #[cfg(not(windows))]
13484     unimplemented!("Unsupported target OS");
13485 }
13486 #[inline]
UuidCreateSequential(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS13487 pub unsafe fn UuidCreateSequential(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
13488     #[cfg(windows)]
13489     {
13490         #[link(name = "windows")]
13491         extern "system" {
13492             fn UuidCreateSequential(uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
13493         }
13494         ::std::mem::transmute(UuidCreateSequential(::std::mem::transmute(uuid)))
13495     }
13496     #[cfg(not(windows))]
13497     unimplemented!("Unsupported target OS");
13498 }
13499 #[inline]
UuidEqual(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i3213500 pub unsafe fn UuidEqual(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32 {
13501     #[cfg(windows)]
13502     {
13503         #[link(name = "windows")]
13504         extern "system" {
13505             fn UuidEqual(uuid1: *const ::windows::runtime::GUID, uuid2: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32;
13506         }
13507         ::std::mem::transmute(UuidEqual(::std::mem::transmute(uuid1), ::std::mem::transmute(uuid2), ::std::mem::transmute(status)))
13508     }
13509     #[cfg(not(windows))]
13510     unimplemented!("Unsupported target OS");
13511 }
13512 #[inline]
UuidFromStringA(stringuuid: *const u8, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS13513 pub unsafe fn UuidFromStringA(stringuuid: *const u8, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
13514     #[cfg(windows)]
13515     {
13516         #[link(name = "windows")]
13517         extern "system" {
13518             fn UuidFromStringA(stringuuid: *const u8, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
13519         }
13520         ::std::mem::transmute(UuidFromStringA(::std::mem::transmute(stringuuid), ::std::mem::transmute(uuid)))
13521     }
13522     #[cfg(not(windows))]
13523     unimplemented!("Unsupported target OS");
13524 }
13525 #[inline]
UuidFromStringW(stringuuid: *const u16, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS13526 pub unsafe fn UuidFromStringW(stringuuid: *const u16, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS {
13527     #[cfg(windows)]
13528     {
13529         #[link(name = "windows")]
13530         extern "system" {
13531             fn UuidFromStringW(stringuuid: *const u16, uuid: *mut ::windows::runtime::GUID) -> RPC_STATUS;
13532         }
13533         ::std::mem::transmute(UuidFromStringW(::std::mem::transmute(stringuuid), ::std::mem::transmute(uuid)))
13534     }
13535     #[cfg(not(windows))]
13536     unimplemented!("Unsupported target OS");
13537 }
13538 #[inline]
UuidHash(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> u1613539 pub unsafe fn UuidHash(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> u16 {
13540     #[cfg(windows)]
13541     {
13542         #[link(name = "windows")]
13543         extern "system" {
13544             fn UuidHash(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> u16;
13545         }
13546         ::std::mem::transmute(UuidHash(::std::mem::transmute(uuid), ::std::mem::transmute(status)))
13547     }
13548     #[cfg(not(windows))]
13549     unimplemented!("Unsupported target OS");
13550 }
13551 #[inline]
UuidIsNil(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i3213552 pub unsafe fn UuidIsNil(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32 {
13553     #[cfg(windows)]
13554     {
13555         #[link(name = "windows")]
13556         extern "system" {
13557             fn UuidIsNil(uuid: *const ::windows::runtime::GUID, status: *mut RPC_STATUS) -> i32;
13558         }
13559         ::std::mem::transmute(UuidIsNil(::std::mem::transmute(uuid), ::std::mem::transmute(status)))
13560     }
13561     #[cfg(not(windows))]
13562     unimplemented!("Unsupported target OS");
13563 }
13564 #[inline]
UuidToStringA(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u8) -> RPC_STATUS13565 pub unsafe fn UuidToStringA(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u8) -> RPC_STATUS {
13566     #[cfg(windows)]
13567     {
13568         #[link(name = "windows")]
13569         extern "system" {
13570             fn UuidToStringA(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u8) -> RPC_STATUS;
13571         }
13572         ::std::mem::transmute(UuidToStringA(::std::mem::transmute(uuid), ::std::mem::transmute(stringuuid)))
13573     }
13574     #[cfg(not(windows))]
13575     unimplemented!("Unsupported target OS");
13576 }
13577 #[inline]
UuidToStringW(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u16) -> RPC_STATUS13578 pub unsafe fn UuidToStringW(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u16) -> RPC_STATUS {
13579     #[cfg(windows)]
13580     {
13581         #[link(name = "windows")]
13582         extern "system" {
13583             fn UuidToStringW(uuid: *const ::windows::runtime::GUID, stringuuid: *mut *mut u16) -> RPC_STATUS;
13584         }
13585         ::std::mem::transmute(UuidToStringW(::std::mem::transmute(uuid), ::std::mem::transmute(stringuuid)))
13586     }
13587     #[cfg(not(windows))]
13588     unimplemented!("Unsupported target OS");
13589 }
13590 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13591 #[repr(transparent)]
13592 pub struct XLAT_SIDE(pub i32);
13593 pub const XLAT_SERVER: XLAT_SIDE = XLAT_SIDE(1i32);
13594 pub const XLAT_CLIENT: XLAT_SIDE = XLAT_SIDE(2i32);
13595 impl ::std::convert::From<i32> for XLAT_SIDE {
from(value: i32) -> Self13596     fn from(value: i32) -> Self {
13597         Self(value)
13598     }
13599 }
13600 unsafe impl ::windows::runtime::Abi for XLAT_SIDE {
13601     type Abi = Self;
13602     type DefaultType = Self;
13603 }
13604 #[cfg(feature = "Win32_System_Com")]
13605 pub type XMIT_HELPER_ROUTINE = unsafe extern "system" fn(param0: *mut ::std::mem::ManuallyDrop<MIDL_STUB_MESSAGE>);
13606 #[derive(:: std :: clone :: Clone)]
13607 #[repr(C)]
13608 #[cfg(feature = "Win32_System_Com")]
13609 pub struct XMIT_ROUTINE_QUINTUPLE {
13610     pub pfnTranslateToXmit: ::std::option::Option<XMIT_HELPER_ROUTINE>,
13611     pub pfnTranslateFromXmit: ::std::option::Option<XMIT_HELPER_ROUTINE>,
13612     pub pfnFreeXmit: ::std::option::Option<XMIT_HELPER_ROUTINE>,
13613     pub pfnFreeInst: ::std::option::Option<XMIT_HELPER_ROUTINE>,
13614 }
13615 #[cfg(feature = "Win32_System_Com")]
13616 impl XMIT_ROUTINE_QUINTUPLE {}
13617 #[cfg(feature = "Win32_System_Com")]
13618 impl ::std::default::Default for XMIT_ROUTINE_QUINTUPLE {
default() -> Self13619     fn default() -> Self {
13620         unsafe { ::std::mem::zeroed() }
13621     }
13622 }
13623 #[cfg(feature = "Win32_System_Com")]
13624 impl ::std::fmt::Debug for XMIT_ROUTINE_QUINTUPLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13625     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13626         fmt.debug_struct("XMIT_ROUTINE_QUINTUPLE").finish()
13627     }
13628 }
13629 #[cfg(feature = "Win32_System_Com")]
13630 impl ::std::cmp::PartialEq for XMIT_ROUTINE_QUINTUPLE {
eq(&self, other: &Self) -> bool13631     fn eq(&self, other: &Self) -> bool {
13632         self.pfnTranslateToXmit.map(|f| f as usize) == other.pfnTranslateToXmit.map(|f| f as usize) && self.pfnTranslateFromXmit.map(|f| f as usize) == other.pfnTranslateFromXmit.map(|f| f as usize) && self.pfnFreeXmit.map(|f| f as usize) == other.pfnFreeXmit.map(|f| f as usize) && self.pfnFreeInst.map(|f| f as usize) == other.pfnFreeInst.map(|f| f as usize)
13633     }
13634 }
13635 #[cfg(feature = "Win32_System_Com")]
13636 impl ::std::cmp::Eq for XMIT_ROUTINE_QUINTUPLE {}
13637 #[cfg(feature = "Win32_System_Com")]
13638 unsafe impl ::windows::runtime::Abi for XMIT_ROUTINE_QUINTUPLE {
13639     type Abi = ::std::mem::ManuallyDrop<Self>;
13640     type DefaultType = Self;
13641 }
13642 #[repr(C)]
13643 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
13644 pub struct _NDR_ASYNC_MESSAGE(pub u8);
13645 #[repr(C)]
13646 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
13647 pub struct _NDR_CORRELATION_INFO(pub u8);
13648 #[repr(C)]
13649 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
13650 pub struct _NDR_PROC_CONTEXT(pub u8);
13651 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13652 #[repr(C)]
13653 pub struct _NDR_SCONTEXT {
13654     pub pad: [*mut ::std::ffi::c_void; 2],
13655     pub userContext: *mut ::std::ffi::c_void,
13656 }
13657 impl _NDR_SCONTEXT {}
13658 impl ::std::default::Default for _NDR_SCONTEXT {
default() -> Self13659     fn default() -> Self {
13660         unsafe { ::std::mem::zeroed() }
13661     }
13662 }
13663 impl ::std::fmt::Debug for _NDR_SCONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13664     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13665         fmt.debug_struct("_NDR_SCONTEXT").field("pad", &self.pad).field("userContext", &self.userContext).finish()
13666     }
13667 }
13668 impl ::std::cmp::PartialEq for _NDR_SCONTEXT {
eq(&self, other: &Self) -> bool13669     fn eq(&self, other: &Self) -> bool {
13670         self.pad == other.pad && self.userContext == other.userContext
13671     }
13672 }
13673 impl ::std::cmp::Eq for _NDR_SCONTEXT {}
13674 unsafe impl ::windows::runtime::Abi for _NDR_SCONTEXT {
13675     type Abi = Self;
13676     type DefaultType = Self;
13677 }
13678 pub const __RPCPROXY_H_VERSION__: u32 = 475u32;
13679 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13680 #[repr(transparent)]
13681 pub struct system_handle_t(pub i32);
13682 pub const SYSTEM_HANDLE_FILE: system_handle_t = system_handle_t(0i32);
13683 pub const SYSTEM_HANDLE_SEMAPHORE: system_handle_t = system_handle_t(1i32);
13684 pub const SYSTEM_HANDLE_EVENT: system_handle_t = system_handle_t(2i32);
13685 pub const SYSTEM_HANDLE_MUTEX: system_handle_t = system_handle_t(3i32);
13686 pub const SYSTEM_HANDLE_PROCESS: system_handle_t = system_handle_t(4i32);
13687 pub const SYSTEM_HANDLE_TOKEN: system_handle_t = system_handle_t(5i32);
13688 pub const SYSTEM_HANDLE_SECTION: system_handle_t = system_handle_t(6i32);
13689 pub const SYSTEM_HANDLE_REG_KEY: system_handle_t = system_handle_t(7i32);
13690 pub const SYSTEM_HANDLE_THREAD: system_handle_t = system_handle_t(8i32);
13691 pub const SYSTEM_HANDLE_COMPOSITION_OBJECT: system_handle_t = system_handle_t(9i32);
13692 pub const SYSTEM_HANDLE_SOCKET: system_handle_t = system_handle_t(10i32);
13693 pub const SYSTEM_HANDLE_JOB: system_handle_t = system_handle_t(11i32);
13694 pub const SYSTEM_HANDLE_PIPE: system_handle_t = system_handle_t(12i32);
13695 pub const SYSTEM_HANDLE_MAX: system_handle_t = system_handle_t(12i32);
13696 pub const SYSTEM_HANDLE_INVALID: system_handle_t = system_handle_t(255i32);
13697 impl ::std::convert::From<i32> for system_handle_t {
from(value: i32) -> Self13698     fn from(value: i32) -> Self {
13699         Self(value)
13700     }
13701 }
13702 unsafe impl ::windows::runtime::Abi for system_handle_t {
13703     type Abi = Self;
13704     type DefaultType = Self;
13705 }
13706