1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const ADDRESS_TYPE_IANA: u32 = 0u32;
3 pub const ADDRESS_TYPE_IATA: u32 = 1u32;
4 pub const CHANGESTATE: u32 = 4u32;
5 pub const CLIENT_TYPE_BOOTP: u32 = 2u32;
6 pub const CLIENT_TYPE_DHCP: u32 = 1u32;
7 pub const CLIENT_TYPE_NONE: u32 = 100u32;
8 pub const CLIENT_TYPE_RESERVATION_FLAG: u32 = 4u32;
9 pub const CLIENT_TYPE_UNSPECIFIED: u32 = 0u32;
10 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11 #[repr(C)]
12 pub struct DATE_TIME {
13     pub dwLowDateTime: u32,
14     pub dwHighDateTime: u32,
15 }
16 impl DATE_TIME {}
17 impl ::std::default::Default for DATE_TIME {
default() -> Self18     fn default() -> Self {
19         unsafe { ::std::mem::zeroed() }
20     }
21 }
22 impl ::std::fmt::Debug for DATE_TIME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24         fmt.debug_struct("DATE_TIME").field("dwLowDateTime", &self.dwLowDateTime).field("dwHighDateTime", &self.dwHighDateTime).finish()
25     }
26 }
27 impl ::std::cmp::PartialEq for DATE_TIME {
eq(&self, other: &Self) -> bool28     fn eq(&self, other: &Self) -> bool {
29         self.dwLowDateTime == other.dwLowDateTime && self.dwHighDateTime == other.dwHighDateTime
30     }
31 }
32 impl ::std::cmp::Eq for DATE_TIME {}
33 unsafe impl ::windows::runtime::Abi for DATE_TIME {
34     type Abi = Self;
35     type DefaultType = Self;
36 }
37 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
38 #[repr(C)]
39 #[cfg(feature = "Win32_Foundation")]
40 pub struct DHCPAPI_PARAMS {
41     pub Flags: u32,
42     pub OptionId: u32,
43     pub IsVendor: super::super::Foundation::BOOL,
44     pub Data: *mut u8,
45     pub nBytesData: u32,
46 }
47 #[cfg(feature = "Win32_Foundation")]
48 impl DHCPAPI_PARAMS {}
49 #[cfg(feature = "Win32_Foundation")]
50 impl ::std::default::Default for DHCPAPI_PARAMS {
default() -> Self51     fn default() -> Self {
52         unsafe { ::std::mem::zeroed() }
53     }
54 }
55 #[cfg(feature = "Win32_Foundation")]
56 impl ::std::fmt::Debug for DHCPAPI_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result57     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
58         fmt.debug_struct("DHCPAPI_PARAMS").field("Flags", &self.Flags).field("OptionId", &self.OptionId).field("IsVendor", &self.IsVendor).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
59     }
60 }
61 #[cfg(feature = "Win32_Foundation")]
62 impl ::std::cmp::PartialEq for DHCPAPI_PARAMS {
eq(&self, other: &Self) -> bool63     fn eq(&self, other: &Self) -> bool {
64         self.Flags == other.Flags && self.OptionId == other.OptionId && self.IsVendor == other.IsVendor && self.Data == other.Data && self.nBytesData == other.nBytesData
65     }
66 }
67 #[cfg(feature = "Win32_Foundation")]
68 impl ::std::cmp::Eq for DHCPAPI_PARAMS {}
69 #[cfg(feature = "Win32_Foundation")]
70 unsafe impl ::windows::runtime::Abi for DHCPAPI_PARAMS {
71     type Abi = Self;
72     type DefaultType = Self;
73 }
74 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
75 #[repr(C)]
76 pub struct DHCPCAPI_CLASSID {
77     pub Flags: u32,
78     pub Data: *mut u8,
79     pub nBytesData: u32,
80 }
81 impl DHCPCAPI_CLASSID {}
82 impl ::std::default::Default for DHCPCAPI_CLASSID {
default() -> Self83     fn default() -> Self {
84         unsafe { ::std::mem::zeroed() }
85     }
86 }
87 impl ::std::fmt::Debug for DHCPCAPI_CLASSID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result88     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
89         fmt.debug_struct("DHCPCAPI_CLASSID").field("Flags", &self.Flags).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
90     }
91 }
92 impl ::std::cmp::PartialEq for DHCPCAPI_CLASSID {
eq(&self, other: &Self) -> bool93     fn eq(&self, other: &Self) -> bool {
94         self.Flags == other.Flags && self.Data == other.Data && self.nBytesData == other.nBytesData
95     }
96 }
97 impl ::std::cmp::Eq for DHCPCAPI_CLASSID {}
98 unsafe impl ::windows::runtime::Abi for DHCPCAPI_CLASSID {
99     type Abi = Self;
100     type DefaultType = Self;
101 }
102 pub const DHCPCAPI_DEREGISTER_HANDLE_EVENT: u32 = 1u32;
103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
104 #[repr(C)]
105 #[cfg(feature = "Win32_Foundation")]
106 pub struct DHCPCAPI_PARAMS_ARRAY {
107     pub nParams: u32,
108     pub Params: *mut DHCPAPI_PARAMS,
109 }
110 #[cfg(feature = "Win32_Foundation")]
111 impl DHCPCAPI_PARAMS_ARRAY {}
112 #[cfg(feature = "Win32_Foundation")]
113 impl ::std::default::Default for DHCPCAPI_PARAMS_ARRAY {
default() -> Self114     fn default() -> Self {
115         unsafe { ::std::mem::zeroed() }
116     }
117 }
118 #[cfg(feature = "Win32_Foundation")]
119 impl ::std::fmt::Debug for DHCPCAPI_PARAMS_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result120     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
121         fmt.debug_struct("DHCPCAPI_PARAMS_ARRAY").field("nParams", &self.nParams).field("Params", &self.Params).finish()
122     }
123 }
124 #[cfg(feature = "Win32_Foundation")]
125 impl ::std::cmp::PartialEq for DHCPCAPI_PARAMS_ARRAY {
eq(&self, other: &Self) -> bool126     fn eq(&self, other: &Self) -> bool {
127         self.nParams == other.nParams && self.Params == other.Params
128     }
129 }
130 #[cfg(feature = "Win32_Foundation")]
131 impl ::std::cmp::Eq for DHCPCAPI_PARAMS_ARRAY {}
132 #[cfg(feature = "Win32_Foundation")]
133 unsafe impl ::windows::runtime::Abi for DHCPCAPI_PARAMS_ARRAY {
134     type Abi = Self;
135     type DefaultType = Self;
136 }
137 pub const DHCPCAPI_REGISTER_HANDLE_EVENT: u32 = 1u32;
138 pub const DHCPCAPI_REQUEST_ASYNCHRONOUS: u32 = 4u32;
139 pub const DHCPCAPI_REQUEST_CANCEL: u32 = 8u32;
140 pub const DHCPCAPI_REQUEST_MASK: u32 = 15u32;
141 pub const DHCPCAPI_REQUEST_PERSISTENT: u32 = 1u32;
142 pub const DHCPCAPI_REQUEST_SYNCHRONOUS: u32 = 2u32;
143 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
144 #[repr(C)]
145 #[cfg(feature = "Win32_Foundation")]
146 pub struct DHCPDS_SERVER {
147     pub Version: u32,
148     pub ServerName: super::super::Foundation::PWSTR,
149     pub ServerAddress: u32,
150     pub Flags: u32,
151     pub State: u32,
152     pub DsLocation: super::super::Foundation::PWSTR,
153     pub DsLocType: u32,
154 }
155 #[cfg(feature = "Win32_Foundation")]
156 impl DHCPDS_SERVER {}
157 #[cfg(feature = "Win32_Foundation")]
158 impl ::std::default::Default for DHCPDS_SERVER {
default() -> Self159     fn default() -> Self {
160         unsafe { ::std::mem::zeroed() }
161     }
162 }
163 #[cfg(feature = "Win32_Foundation")]
164 impl ::std::fmt::Debug for DHCPDS_SERVER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result165     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
166         fmt.debug_struct("DHCPDS_SERVER").field("Version", &self.Version).field("ServerName", &self.ServerName).field("ServerAddress", &self.ServerAddress).field("Flags", &self.Flags).field("State", &self.State).field("DsLocation", &self.DsLocation).field("DsLocType", &self.DsLocType).finish()
167     }
168 }
169 #[cfg(feature = "Win32_Foundation")]
170 impl ::std::cmp::PartialEq for DHCPDS_SERVER {
eq(&self, other: &Self) -> bool171     fn eq(&self, other: &Self) -> bool {
172         self.Version == other.Version && self.ServerName == other.ServerName && self.ServerAddress == other.ServerAddress && self.Flags == other.Flags && self.State == other.State && self.DsLocation == other.DsLocation && self.DsLocType == other.DsLocType
173     }
174 }
175 #[cfg(feature = "Win32_Foundation")]
176 impl ::std::cmp::Eq for DHCPDS_SERVER {}
177 #[cfg(feature = "Win32_Foundation")]
178 unsafe impl ::windows::runtime::Abi for DHCPDS_SERVER {
179     type Abi = Self;
180     type DefaultType = Self;
181 }
182 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
183 #[repr(C)]
184 #[cfg(feature = "Win32_Foundation")]
185 pub struct DHCPDS_SERVERS {
186     pub Flags: u32,
187     pub NumElements: u32,
188     pub Servers: *mut DHCPDS_SERVER,
189 }
190 #[cfg(feature = "Win32_Foundation")]
191 impl DHCPDS_SERVERS {}
192 #[cfg(feature = "Win32_Foundation")]
193 impl ::std::default::Default for DHCPDS_SERVERS {
default() -> Self194     fn default() -> Self {
195         unsafe { ::std::mem::zeroed() }
196     }
197 }
198 #[cfg(feature = "Win32_Foundation")]
199 impl ::std::fmt::Debug for DHCPDS_SERVERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result200     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
201         fmt.debug_struct("DHCPDS_SERVERS").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Servers", &self.Servers).finish()
202     }
203 }
204 #[cfg(feature = "Win32_Foundation")]
205 impl ::std::cmp::PartialEq for DHCPDS_SERVERS {
eq(&self, other: &Self) -> bool206     fn eq(&self, other: &Self) -> bool {
207         self.Flags == other.Flags && self.NumElements == other.NumElements && self.Servers == other.Servers
208     }
209 }
210 #[cfg(feature = "Win32_Foundation")]
211 impl ::std::cmp::Eq for DHCPDS_SERVERS {}
212 #[cfg(feature = "Win32_Foundation")]
213 unsafe impl ::windows::runtime::Abi for DHCPDS_SERVERS {
214     type Abi = Self;
215     type DefaultType = Self;
216 }
217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
218 #[repr(C)]
219 #[cfg(feature = "Win32_Foundation")]
220 pub struct DHCPV4_FAILOVER_CLIENT_INFO {
221     pub ClientIpAddress: u32,
222     pub SubnetMask: u32,
223     pub ClientHardwareAddress: DHCP_BINARY_DATA,
224     pub ClientName: super::super::Foundation::PWSTR,
225     pub ClientComment: super::super::Foundation::PWSTR,
226     pub ClientLeaseExpires: DATE_TIME,
227     pub OwnerHost: DHCP_HOST_INFO,
228     pub bClientType: u8,
229     pub AddressState: u8,
230     pub Status: QuarantineStatus,
231     pub ProbationEnds: DATE_TIME,
232     pub QuarantineCapable: super::super::Foundation::BOOL,
233     pub SentPotExpTime: u32,
234     pub AckPotExpTime: u32,
235     pub RecvPotExpTime: u32,
236     pub StartTime: u32,
237     pub CltLastTransTime: u32,
238     pub LastBndUpdTime: u32,
239     pub BndMsgStatus: u32,
240     pub PolicyName: super::super::Foundation::PWSTR,
241     pub Flags: u8,
242 }
243 #[cfg(feature = "Win32_Foundation")]
244 impl DHCPV4_FAILOVER_CLIENT_INFO {}
245 #[cfg(feature = "Win32_Foundation")]
246 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO {
default() -> Self247     fn default() -> Self {
248         unsafe { ::std::mem::zeroed() }
249     }
250 }
251 #[cfg(feature = "Win32_Foundation")]
252 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result253     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
254         fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO")
255             .field("ClientIpAddress", &self.ClientIpAddress)
256             .field("SubnetMask", &self.SubnetMask)
257             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
258             .field("ClientName", &self.ClientName)
259             .field("ClientComment", &self.ClientComment)
260             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
261             .field("OwnerHost", &self.OwnerHost)
262             .field("bClientType", &self.bClientType)
263             .field("AddressState", &self.AddressState)
264             .field("Status", &self.Status)
265             .field("ProbationEnds", &self.ProbationEnds)
266             .field("QuarantineCapable", &self.QuarantineCapable)
267             .field("SentPotExpTime", &self.SentPotExpTime)
268             .field("AckPotExpTime", &self.AckPotExpTime)
269             .field("RecvPotExpTime", &self.RecvPotExpTime)
270             .field("StartTime", &self.StartTime)
271             .field("CltLastTransTime", &self.CltLastTransTime)
272             .field("LastBndUpdTime", &self.LastBndUpdTime)
273             .field("BndMsgStatus", &self.BndMsgStatus)
274             .field("PolicyName", &self.PolicyName)
275             .field("Flags", &self.Flags)
276             .finish()
277     }
278 }
279 #[cfg(feature = "Win32_Foundation")]
280 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO {
eq(&self, other: &Self) -> bool281     fn eq(&self, other: &Self) -> bool {
282         self.ClientIpAddress == other.ClientIpAddress
283             && self.SubnetMask == other.SubnetMask
284             && self.ClientHardwareAddress == other.ClientHardwareAddress
285             && self.ClientName == other.ClientName
286             && self.ClientComment == other.ClientComment
287             && self.ClientLeaseExpires == other.ClientLeaseExpires
288             && self.OwnerHost == other.OwnerHost
289             && self.bClientType == other.bClientType
290             && self.AddressState == other.AddressState
291             && self.Status == other.Status
292             && self.ProbationEnds == other.ProbationEnds
293             && self.QuarantineCapable == other.QuarantineCapable
294             && self.SentPotExpTime == other.SentPotExpTime
295             && self.AckPotExpTime == other.AckPotExpTime
296             && self.RecvPotExpTime == other.RecvPotExpTime
297             && self.StartTime == other.StartTime
298             && self.CltLastTransTime == other.CltLastTransTime
299             && self.LastBndUpdTime == other.LastBndUpdTime
300             && self.BndMsgStatus == other.BndMsgStatus
301             && self.PolicyName == other.PolicyName
302             && self.Flags == other.Flags
303     }
304 }
305 #[cfg(feature = "Win32_Foundation")]
306 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO {}
307 #[cfg(feature = "Win32_Foundation")]
308 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO {
309     type Abi = Self;
310     type DefaultType = Self;
311 }
312 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
313 #[repr(C)]
314 #[cfg(feature = "Win32_Foundation")]
315 pub struct DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
316     pub NumElements: u32,
317     pub Clients: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO,
318 }
319 #[cfg(feature = "Win32_Foundation")]
320 impl DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {}
321 #[cfg(feature = "Win32_Foundation")]
322 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
default() -> Self323     fn default() -> Self {
324         unsafe { ::std::mem::zeroed() }
325     }
326 }
327 #[cfg(feature = "Win32_Foundation")]
328 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result329     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
330         fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
331     }
332 }
333 #[cfg(feature = "Win32_Foundation")]
334 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool335     fn eq(&self, other: &Self) -> bool {
336         self.NumElements == other.NumElements && self.Clients == other.Clients
337     }
338 }
339 #[cfg(feature = "Win32_Foundation")]
340 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {}
341 #[cfg(feature = "Win32_Foundation")]
342 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
343     type Abi = Self;
344     type DefaultType = Self;
345 }
346 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
347 #[repr(C)]
348 #[cfg(feature = "Win32_Foundation")]
349 pub struct DHCPV4_FAILOVER_CLIENT_INFO_EX {
350     pub ClientIpAddress: u32,
351     pub SubnetMask: u32,
352     pub ClientHardwareAddress: DHCP_BINARY_DATA,
353     pub ClientName: super::super::Foundation::PWSTR,
354     pub ClientComment: super::super::Foundation::PWSTR,
355     pub ClientLeaseExpires: DATE_TIME,
356     pub OwnerHost: DHCP_HOST_INFO,
357     pub bClientType: u8,
358     pub AddressState: u8,
359     pub Status: QuarantineStatus,
360     pub ProbationEnds: DATE_TIME,
361     pub QuarantineCapable: super::super::Foundation::BOOL,
362     pub SentPotExpTime: u32,
363     pub AckPotExpTime: u32,
364     pub RecvPotExpTime: u32,
365     pub StartTime: u32,
366     pub CltLastTransTime: u32,
367     pub LastBndUpdTime: u32,
368     pub BndMsgStatus: u32,
369     pub PolicyName: super::super::Foundation::PWSTR,
370     pub Flags: u8,
371     pub AddressStateEx: u32,
372 }
373 #[cfg(feature = "Win32_Foundation")]
374 impl DHCPV4_FAILOVER_CLIENT_INFO_EX {}
375 #[cfg(feature = "Win32_Foundation")]
376 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO_EX {
default() -> Self377     fn default() -> Self {
378         unsafe { ::std::mem::zeroed() }
379     }
380 }
381 #[cfg(feature = "Win32_Foundation")]
382 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result383     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
384         fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO_EX")
385             .field("ClientIpAddress", &self.ClientIpAddress)
386             .field("SubnetMask", &self.SubnetMask)
387             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
388             .field("ClientName", &self.ClientName)
389             .field("ClientComment", &self.ClientComment)
390             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
391             .field("OwnerHost", &self.OwnerHost)
392             .field("bClientType", &self.bClientType)
393             .field("AddressState", &self.AddressState)
394             .field("Status", &self.Status)
395             .field("ProbationEnds", &self.ProbationEnds)
396             .field("QuarantineCapable", &self.QuarantineCapable)
397             .field("SentPotExpTime", &self.SentPotExpTime)
398             .field("AckPotExpTime", &self.AckPotExpTime)
399             .field("RecvPotExpTime", &self.RecvPotExpTime)
400             .field("StartTime", &self.StartTime)
401             .field("CltLastTransTime", &self.CltLastTransTime)
402             .field("LastBndUpdTime", &self.LastBndUpdTime)
403             .field("BndMsgStatus", &self.BndMsgStatus)
404             .field("PolicyName", &self.PolicyName)
405             .field("Flags", &self.Flags)
406             .field("AddressStateEx", &self.AddressStateEx)
407             .finish()
408     }
409 }
410 #[cfg(feature = "Win32_Foundation")]
411 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO_EX {
eq(&self, other: &Self) -> bool412     fn eq(&self, other: &Self) -> bool {
413         self.ClientIpAddress == other.ClientIpAddress
414             && self.SubnetMask == other.SubnetMask
415             && self.ClientHardwareAddress == other.ClientHardwareAddress
416             && self.ClientName == other.ClientName
417             && self.ClientComment == other.ClientComment
418             && self.ClientLeaseExpires == other.ClientLeaseExpires
419             && self.OwnerHost == other.OwnerHost
420             && self.bClientType == other.bClientType
421             && self.AddressState == other.AddressState
422             && self.Status == other.Status
423             && self.ProbationEnds == other.ProbationEnds
424             && self.QuarantineCapable == other.QuarantineCapable
425             && self.SentPotExpTime == other.SentPotExpTime
426             && self.AckPotExpTime == other.AckPotExpTime
427             && self.RecvPotExpTime == other.RecvPotExpTime
428             && self.StartTime == other.StartTime
429             && self.CltLastTransTime == other.CltLastTransTime
430             && self.LastBndUpdTime == other.LastBndUpdTime
431             && self.BndMsgStatus == other.BndMsgStatus
432             && self.PolicyName == other.PolicyName
433             && self.Flags == other.Flags
434             && self.AddressStateEx == other.AddressStateEx
435     }
436 }
437 #[cfg(feature = "Win32_Foundation")]
438 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO_EX {}
439 #[cfg(feature = "Win32_Foundation")]
440 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO_EX {
441     type Abi = Self;
442     type DefaultType = Self;
443 }
444 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
445 #[repr(C)]
446 pub struct DHCPV6CAPI_CLASSID {
447     pub Flags: u32,
448     pub Data: *mut u8,
449     pub nBytesData: u32,
450 }
451 impl DHCPV6CAPI_CLASSID {}
452 impl ::std::default::Default for DHCPV6CAPI_CLASSID {
default() -> Self453     fn default() -> Self {
454         unsafe { ::std::mem::zeroed() }
455     }
456 }
457 impl ::std::fmt::Debug for DHCPV6CAPI_CLASSID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result458     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
459         fmt.debug_struct("DHCPV6CAPI_CLASSID").field("Flags", &self.Flags).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
460     }
461 }
462 impl ::std::cmp::PartialEq for DHCPV6CAPI_CLASSID {
eq(&self, other: &Self) -> bool463     fn eq(&self, other: &Self) -> bool {
464         self.Flags == other.Flags && self.Data == other.Data && self.nBytesData == other.nBytesData
465     }
466 }
467 impl ::std::cmp::Eq for DHCPV6CAPI_CLASSID {}
468 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_CLASSID {
469     type Abi = Self;
470     type DefaultType = Self;
471 }
472 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
473 #[repr(C)]
474 #[cfg(feature = "Win32_Foundation")]
475 pub struct DHCPV6CAPI_PARAMS {
476     pub Flags: u32,
477     pub OptionId: u32,
478     pub IsVendor: super::super::Foundation::BOOL,
479     pub Data: *mut u8,
480     pub nBytesData: u32,
481 }
482 #[cfg(feature = "Win32_Foundation")]
483 impl DHCPV6CAPI_PARAMS {}
484 #[cfg(feature = "Win32_Foundation")]
485 impl ::std::default::Default for DHCPV6CAPI_PARAMS {
default() -> Self486     fn default() -> Self {
487         unsafe { ::std::mem::zeroed() }
488     }
489 }
490 #[cfg(feature = "Win32_Foundation")]
491 impl ::std::fmt::Debug for DHCPV6CAPI_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result492     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
493         fmt.debug_struct("DHCPV6CAPI_PARAMS").field("Flags", &self.Flags).field("OptionId", &self.OptionId).field("IsVendor", &self.IsVendor).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
494     }
495 }
496 #[cfg(feature = "Win32_Foundation")]
497 impl ::std::cmp::PartialEq for DHCPV6CAPI_PARAMS {
eq(&self, other: &Self) -> bool498     fn eq(&self, other: &Self) -> bool {
499         self.Flags == other.Flags && self.OptionId == other.OptionId && self.IsVendor == other.IsVendor && self.Data == other.Data && self.nBytesData == other.nBytesData
500     }
501 }
502 #[cfg(feature = "Win32_Foundation")]
503 impl ::std::cmp::Eq for DHCPV6CAPI_PARAMS {}
504 #[cfg(feature = "Win32_Foundation")]
505 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_PARAMS {
506     type Abi = Self;
507     type DefaultType = Self;
508 }
509 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
510 #[repr(C)]
511 #[cfg(feature = "Win32_Foundation")]
512 pub struct DHCPV6CAPI_PARAMS_ARRAY {
513     pub nParams: u32,
514     pub Params: *mut DHCPV6CAPI_PARAMS,
515 }
516 #[cfg(feature = "Win32_Foundation")]
517 impl DHCPV6CAPI_PARAMS_ARRAY {}
518 #[cfg(feature = "Win32_Foundation")]
519 impl ::std::default::Default for DHCPV6CAPI_PARAMS_ARRAY {
default() -> Self520     fn default() -> Self {
521         unsafe { ::std::mem::zeroed() }
522     }
523 }
524 #[cfg(feature = "Win32_Foundation")]
525 impl ::std::fmt::Debug for DHCPV6CAPI_PARAMS_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result526     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
527         fmt.debug_struct("DHCPV6CAPI_PARAMS_ARRAY").field("nParams", &self.nParams).field("Params", &self.Params).finish()
528     }
529 }
530 #[cfg(feature = "Win32_Foundation")]
531 impl ::std::cmp::PartialEq for DHCPV6CAPI_PARAMS_ARRAY {
eq(&self, other: &Self) -> bool532     fn eq(&self, other: &Self) -> bool {
533         self.nParams == other.nParams && self.Params == other.Params
534     }
535 }
536 #[cfg(feature = "Win32_Foundation")]
537 impl ::std::cmp::Eq for DHCPV6CAPI_PARAMS_ARRAY {}
538 #[cfg(feature = "Win32_Foundation")]
539 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_PARAMS_ARRAY {
540     type Abi = Self;
541     type DefaultType = Self;
542 }
543 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
544 #[repr(C)]
545 pub struct DHCPV6Prefix {
546     pub prefix: [u8; 16],
547     pub prefixLength: u32,
548     pub preferredLifeTime: u32,
549     pub validLifeTime: u32,
550     pub status: StatusCode,
551 }
552 impl DHCPV6Prefix {}
553 impl ::std::default::Default for DHCPV6Prefix {
default() -> Self554     fn default() -> Self {
555         unsafe { ::std::mem::zeroed() }
556     }
557 }
558 impl ::std::fmt::Debug for DHCPV6Prefix {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result559     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
560         fmt.debug_struct("DHCPV6Prefix").field("prefix", &self.prefix).field("prefixLength", &self.prefixLength).field("preferredLifeTime", &self.preferredLifeTime).field("validLifeTime", &self.validLifeTime).field("status", &self.status).finish()
561     }
562 }
563 impl ::std::cmp::PartialEq for DHCPV6Prefix {
eq(&self, other: &Self) -> bool564     fn eq(&self, other: &Self) -> bool {
565         self.prefix == other.prefix && self.prefixLength == other.prefixLength && self.preferredLifeTime == other.preferredLifeTime && self.validLifeTime == other.validLifeTime && self.status == other.status
566     }
567 }
568 impl ::std::cmp::Eq for DHCPV6Prefix {}
569 unsafe impl ::windows::runtime::Abi for DHCPV6Prefix {
570     type Abi = Self;
571     type DefaultType = Self;
572 }
573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
574 #[repr(C)]
575 pub struct DHCPV6PrefixLeaseInformation {
576     pub nPrefixes: u32,
577     pub prefixArray: *mut DHCPV6Prefix,
578     pub iaid: u32,
579     pub T1: i64,
580     pub T2: i64,
581     pub MaxLeaseExpirationTime: i64,
582     pub LastRenewalTime: i64,
583     pub status: StatusCode,
584     pub ServerId: *mut u8,
585     pub ServerIdLen: u32,
586 }
587 impl DHCPV6PrefixLeaseInformation {}
588 impl ::std::default::Default for DHCPV6PrefixLeaseInformation {
default() -> Self589     fn default() -> Self {
590         unsafe { ::std::mem::zeroed() }
591     }
592 }
593 impl ::std::fmt::Debug for DHCPV6PrefixLeaseInformation {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result594     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
595         fmt.debug_struct("DHCPV6PrefixLeaseInformation")
596             .field("nPrefixes", &self.nPrefixes)
597             .field("prefixArray", &self.prefixArray)
598             .field("iaid", &self.iaid)
599             .field("T1", &self.T1)
600             .field("T2", &self.T2)
601             .field("MaxLeaseExpirationTime", &self.MaxLeaseExpirationTime)
602             .field("LastRenewalTime", &self.LastRenewalTime)
603             .field("status", &self.status)
604             .field("ServerId", &self.ServerId)
605             .field("ServerIdLen", &self.ServerIdLen)
606             .finish()
607     }
608 }
609 impl ::std::cmp::PartialEq for DHCPV6PrefixLeaseInformation {
eq(&self, other: &Self) -> bool610     fn eq(&self, other: &Self) -> bool {
611         self.nPrefixes == other.nPrefixes && self.prefixArray == other.prefixArray && self.iaid == other.iaid && self.T1 == other.T1 && self.T2 == other.T2 && self.MaxLeaseExpirationTime == other.MaxLeaseExpirationTime && self.LastRenewalTime == other.LastRenewalTime && self.status == other.status && self.ServerId == other.ServerId && self.ServerIdLen == other.ServerIdLen
612     }
613 }
614 impl ::std::cmp::Eq for DHCPV6PrefixLeaseInformation {}
615 unsafe impl ::windows::runtime::Abi for DHCPV6PrefixLeaseInformation {
616     type Abi = Self;
617     type DefaultType = Self;
618 }
619 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
620 #[repr(C)]
621 #[cfg(feature = "Win32_Foundation")]
622 pub struct DHCPV6_BIND_ELEMENT {
623     pub Flags: u32,
624     pub fBoundToDHCPServer: super::super::Foundation::BOOL,
625     pub AdapterPrimaryAddress: DHCP_IPV6_ADDRESS,
626     pub AdapterSubnetAddress: DHCP_IPV6_ADDRESS,
627     pub IfDescription: super::super::Foundation::PWSTR,
628     pub IpV6IfIndex: u32,
629     pub IfIdSize: u32,
630     pub IfId: *mut u8,
631 }
632 #[cfg(feature = "Win32_Foundation")]
633 impl DHCPV6_BIND_ELEMENT {}
634 #[cfg(feature = "Win32_Foundation")]
635 impl ::std::default::Default for DHCPV6_BIND_ELEMENT {
default() -> Self636     fn default() -> Self {
637         unsafe { ::std::mem::zeroed() }
638     }
639 }
640 #[cfg(feature = "Win32_Foundation")]
641 impl ::std::fmt::Debug for DHCPV6_BIND_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result642     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
643         fmt.debug_struct("DHCPV6_BIND_ELEMENT")
644             .field("Flags", &self.Flags)
645             .field("fBoundToDHCPServer", &self.fBoundToDHCPServer)
646             .field("AdapterPrimaryAddress", &self.AdapterPrimaryAddress)
647             .field("AdapterSubnetAddress", &self.AdapterSubnetAddress)
648             .field("IfDescription", &self.IfDescription)
649             .field("IpV6IfIndex", &self.IpV6IfIndex)
650             .field("IfIdSize", &self.IfIdSize)
651             .field("IfId", &self.IfId)
652             .finish()
653     }
654 }
655 #[cfg(feature = "Win32_Foundation")]
656 impl ::std::cmp::PartialEq for DHCPV6_BIND_ELEMENT {
eq(&self, other: &Self) -> bool657     fn eq(&self, other: &Self) -> bool {
658         self.Flags == other.Flags && self.fBoundToDHCPServer == other.fBoundToDHCPServer && self.AdapterPrimaryAddress == other.AdapterPrimaryAddress && self.AdapterSubnetAddress == other.AdapterSubnetAddress && self.IfDescription == other.IfDescription && self.IpV6IfIndex == other.IpV6IfIndex && self.IfIdSize == other.IfIdSize && self.IfId == other.IfId
659     }
660 }
661 #[cfg(feature = "Win32_Foundation")]
662 impl ::std::cmp::Eq for DHCPV6_BIND_ELEMENT {}
663 #[cfg(feature = "Win32_Foundation")]
664 unsafe impl ::windows::runtime::Abi for DHCPV6_BIND_ELEMENT {
665     type Abi = Self;
666     type DefaultType = Self;
667 }
668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
669 #[repr(C)]
670 #[cfg(feature = "Win32_Foundation")]
671 pub struct DHCPV6_BIND_ELEMENT_ARRAY {
672     pub NumElements: u32,
673     pub Elements: *mut DHCPV6_BIND_ELEMENT,
674 }
675 #[cfg(feature = "Win32_Foundation")]
676 impl DHCPV6_BIND_ELEMENT_ARRAY {}
677 #[cfg(feature = "Win32_Foundation")]
678 impl ::std::default::Default for DHCPV6_BIND_ELEMENT_ARRAY {
default() -> Self679     fn default() -> Self {
680         unsafe { ::std::mem::zeroed() }
681     }
682 }
683 #[cfg(feature = "Win32_Foundation")]
684 impl ::std::fmt::Debug for DHCPV6_BIND_ELEMENT_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result685     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
686         fmt.debug_struct("DHCPV6_BIND_ELEMENT_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
687     }
688 }
689 #[cfg(feature = "Win32_Foundation")]
690 impl ::std::cmp::PartialEq for DHCPV6_BIND_ELEMENT_ARRAY {
eq(&self, other: &Self) -> bool691     fn eq(&self, other: &Self) -> bool {
692         self.NumElements == other.NumElements && self.Elements == other.Elements
693     }
694 }
695 #[cfg(feature = "Win32_Foundation")]
696 impl ::std::cmp::Eq for DHCPV6_BIND_ELEMENT_ARRAY {}
697 #[cfg(feature = "Win32_Foundation")]
698 unsafe impl ::windows::runtime::Abi for DHCPV6_BIND_ELEMENT_ARRAY {
699     type Abi = Self;
700     type DefaultType = Self;
701 }
702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
703 #[repr(C)]
704 pub struct DHCPV6_IP_ARRAY {
705     pub NumElements: u32,
706     pub Elements: *mut DHCP_IPV6_ADDRESS,
707 }
708 impl DHCPV6_IP_ARRAY {}
709 impl ::std::default::Default for DHCPV6_IP_ARRAY {
default() -> Self710     fn default() -> Self {
711         unsafe { ::std::mem::zeroed() }
712     }
713 }
714 impl ::std::fmt::Debug for DHCPV6_IP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result715     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
716         fmt.debug_struct("DHCPV6_IP_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
717     }
718 }
719 impl ::std::cmp::PartialEq for DHCPV6_IP_ARRAY {
eq(&self, other: &Self) -> bool720     fn eq(&self, other: &Self) -> bool {
721         self.NumElements == other.NumElements && self.Elements == other.Elements
722     }
723 }
724 impl ::std::cmp::Eq for DHCPV6_IP_ARRAY {}
725 unsafe impl ::windows::runtime::Abi for DHCPV6_IP_ARRAY {
726     type Abi = Self;
727     type DefaultType = Self;
728 }
729 pub const DHCPV6_OPTION_CLIENTID: u32 = 1u32;
730 pub const DHCPV6_OPTION_DNS_SERVERS: u32 = 23u32;
731 pub const DHCPV6_OPTION_DOMAIN_LIST: u32 = 24u32;
732 pub const DHCPV6_OPTION_IA_NA: u32 = 3u32;
733 pub const DHCPV6_OPTION_IA_PD: u32 = 25u32;
734 pub const DHCPV6_OPTION_IA_TA: u32 = 4u32;
735 pub const DHCPV6_OPTION_NISP_DOMAIN_NAME: u32 = 30u32;
736 pub const DHCPV6_OPTION_NISP_SERVERS: u32 = 28u32;
737 pub const DHCPV6_OPTION_NIS_DOMAIN_NAME: u32 = 29u32;
738 pub const DHCPV6_OPTION_NIS_SERVERS: u32 = 27u32;
739 pub const DHCPV6_OPTION_ORO: u32 = 6u32;
740 pub const DHCPV6_OPTION_PREFERENCE: u32 = 7u32;
741 pub const DHCPV6_OPTION_RAPID_COMMIT: u32 = 14u32;
742 pub const DHCPV6_OPTION_RECONF_MSG: u32 = 19u32;
743 pub const DHCPV6_OPTION_SERVERID: u32 = 2u32;
744 pub const DHCPV6_OPTION_SIP_SERVERS_ADDRS: u32 = 22u32;
745 pub const DHCPV6_OPTION_SIP_SERVERS_NAMES: u32 = 21u32;
746 pub const DHCPV6_OPTION_UNICAST: u32 = 12u32;
747 pub const DHCPV6_OPTION_USER_CLASS: u32 = 15u32;
748 pub const DHCPV6_OPTION_VENDOR_CLASS: u32 = 16u32;
749 pub const DHCPV6_OPTION_VENDOR_OPTS: u32 = 17u32;
750 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
751 #[repr(C)]
752 #[cfg(feature = "Win32_Foundation")]
753 pub struct DHCPV6_STATELESS_PARAMS {
754     pub Status: super::super::Foundation::BOOL,
755     pub PurgeInterval: u32,
756 }
757 #[cfg(feature = "Win32_Foundation")]
758 impl DHCPV6_STATELESS_PARAMS {}
759 #[cfg(feature = "Win32_Foundation")]
760 impl ::std::default::Default for DHCPV6_STATELESS_PARAMS {
default() -> Self761     fn default() -> Self {
762         unsafe { ::std::mem::zeroed() }
763     }
764 }
765 #[cfg(feature = "Win32_Foundation")]
766 impl ::std::fmt::Debug for DHCPV6_STATELESS_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result767     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
768         fmt.debug_struct("DHCPV6_STATELESS_PARAMS").field("Status", &self.Status).field("PurgeInterval", &self.PurgeInterval).finish()
769     }
770 }
771 #[cfg(feature = "Win32_Foundation")]
772 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_PARAMS {
eq(&self, other: &Self) -> bool773     fn eq(&self, other: &Self) -> bool {
774         self.Status == other.Status && self.PurgeInterval == other.PurgeInterval
775     }
776 }
777 #[cfg(feature = "Win32_Foundation")]
778 impl ::std::cmp::Eq for DHCPV6_STATELESS_PARAMS {}
779 #[cfg(feature = "Win32_Foundation")]
780 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_PARAMS {
781     type Abi = Self;
782     type DefaultType = Self;
783 }
784 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
785 #[repr(transparent)]
786 pub struct DHCPV6_STATELESS_PARAM_TYPE(pub i32);
787 pub const DhcpStatelessPurgeInterval: DHCPV6_STATELESS_PARAM_TYPE = DHCPV6_STATELESS_PARAM_TYPE(1i32);
788 pub const DhcpStatelessStatus: DHCPV6_STATELESS_PARAM_TYPE = DHCPV6_STATELESS_PARAM_TYPE(2i32);
789 impl ::std::convert::From<i32> for DHCPV6_STATELESS_PARAM_TYPE {
from(value: i32) -> Self790     fn from(value: i32) -> Self {
791         Self(value)
792     }
793 }
794 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_PARAM_TYPE {
795     type Abi = Self;
796     type DefaultType = Self;
797 }
798 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
799 #[repr(C)]
800 pub struct DHCPV6_STATELESS_SCOPE_STATS {
801     pub SubnetAddress: DHCP_IPV6_ADDRESS,
802     pub NumStatelessClientsAdded: u64,
803     pub NumStatelessClientsRemoved: u64,
804 }
805 impl DHCPV6_STATELESS_SCOPE_STATS {}
806 impl ::std::default::Default for DHCPV6_STATELESS_SCOPE_STATS {
default() -> Self807     fn default() -> Self {
808         unsafe { ::std::mem::zeroed() }
809     }
810 }
811 impl ::std::fmt::Debug for DHCPV6_STATELESS_SCOPE_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result812     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
813         fmt.debug_struct("DHCPV6_STATELESS_SCOPE_STATS").field("SubnetAddress", &self.SubnetAddress).field("NumStatelessClientsAdded", &self.NumStatelessClientsAdded).field("NumStatelessClientsRemoved", &self.NumStatelessClientsRemoved).finish()
814     }
815 }
816 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_SCOPE_STATS {
eq(&self, other: &Self) -> bool817     fn eq(&self, other: &Self) -> bool {
818         self.SubnetAddress == other.SubnetAddress && self.NumStatelessClientsAdded == other.NumStatelessClientsAdded && self.NumStatelessClientsRemoved == other.NumStatelessClientsRemoved
819     }
820 }
821 impl ::std::cmp::Eq for DHCPV6_STATELESS_SCOPE_STATS {}
822 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_SCOPE_STATS {
823     type Abi = Self;
824     type DefaultType = Self;
825 }
826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
827 #[repr(C)]
828 pub struct DHCPV6_STATELESS_STATS {
829     pub NumScopes: u32,
830     pub ScopeStats: *mut DHCPV6_STATELESS_SCOPE_STATS,
831 }
832 impl DHCPV6_STATELESS_STATS {}
833 impl ::std::default::Default for DHCPV6_STATELESS_STATS {
default() -> Self834     fn default() -> Self {
835         unsafe { ::std::mem::zeroed() }
836     }
837 }
838 impl ::std::fmt::Debug for DHCPV6_STATELESS_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result839     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
840         fmt.debug_struct("DHCPV6_STATELESS_STATS").field("NumScopes", &self.NumScopes).field("ScopeStats", &self.ScopeStats).finish()
841     }
842 }
843 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_STATS {
eq(&self, other: &Self) -> bool844     fn eq(&self, other: &Self) -> bool {
845         self.NumScopes == other.NumScopes && self.ScopeStats == other.ScopeStats
846     }
847 }
848 impl ::std::cmp::Eq for DHCPV6_STATELESS_STATS {}
849 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_STATS {
850     type Abi = Self;
851     type DefaultType = Self;
852 }
853 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
854 #[repr(C)]
855 #[cfg(feature = "Win32_Foundation")]
856 pub struct DHCP_ADDR_PATTERN {
857     pub MatchHWType: super::super::Foundation::BOOL,
858     pub HWType: u8,
859     pub IsWildcard: super::super::Foundation::BOOL,
860     pub Length: u8,
861     pub Pattern: [u8; 255],
862 }
863 #[cfg(feature = "Win32_Foundation")]
864 impl DHCP_ADDR_PATTERN {}
865 #[cfg(feature = "Win32_Foundation")]
866 impl ::std::default::Default for DHCP_ADDR_PATTERN {
default() -> Self867     fn default() -> Self {
868         unsafe { ::std::mem::zeroed() }
869     }
870 }
871 #[cfg(feature = "Win32_Foundation")]
872 impl ::std::fmt::Debug for DHCP_ADDR_PATTERN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result873     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
874         fmt.debug_struct("DHCP_ADDR_PATTERN").field("MatchHWType", &self.MatchHWType).field("HWType", &self.HWType).field("IsWildcard", &self.IsWildcard).field("Length", &self.Length).field("Pattern", &self.Pattern).finish()
875     }
876 }
877 #[cfg(feature = "Win32_Foundation")]
878 impl ::std::cmp::PartialEq for DHCP_ADDR_PATTERN {
eq(&self, other: &Self) -> bool879     fn eq(&self, other: &Self) -> bool {
880         self.MatchHWType == other.MatchHWType && self.HWType == other.HWType && self.IsWildcard == other.IsWildcard && self.Length == other.Length && self.Pattern == other.Pattern
881     }
882 }
883 #[cfg(feature = "Win32_Foundation")]
884 impl ::std::cmp::Eq for DHCP_ADDR_PATTERN {}
885 #[cfg(feature = "Win32_Foundation")]
886 unsafe impl ::windows::runtime::Abi for DHCP_ADDR_PATTERN {
887     type Abi = Self;
888     type DefaultType = Self;
889 }
890 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
891 #[repr(C)]
892 #[cfg(feature = "Win32_Foundation")]
893 pub struct DHCP_ALL_OPTIONS {
894     pub Flags: u32,
895     pub NonVendorOptions: *mut DHCP_OPTION_ARRAY,
896     pub NumVendorOptions: u32,
897     pub VendorOptions: *mut DHCP_ALL_OPTIONS_0,
898 }
899 #[cfg(feature = "Win32_Foundation")]
900 impl DHCP_ALL_OPTIONS {}
901 #[cfg(feature = "Win32_Foundation")]
902 impl ::std::default::Default for DHCP_ALL_OPTIONS {
default() -> Self903     fn default() -> Self {
904         unsafe { ::std::mem::zeroed() }
905     }
906 }
907 #[cfg(feature = "Win32_Foundation")]
908 impl ::std::fmt::Debug for DHCP_ALL_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result909     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
910         fmt.debug_struct("DHCP_ALL_OPTIONS").field("Flags", &self.Flags).field("NonVendorOptions", &self.NonVendorOptions).field("NumVendorOptions", &self.NumVendorOptions).field("VendorOptions", &self.VendorOptions).finish()
911     }
912 }
913 #[cfg(feature = "Win32_Foundation")]
914 impl ::std::cmp::PartialEq for DHCP_ALL_OPTIONS {
eq(&self, other: &Self) -> bool915     fn eq(&self, other: &Self) -> bool {
916         self.Flags == other.Flags && self.NonVendorOptions == other.NonVendorOptions && self.NumVendorOptions == other.NumVendorOptions && self.VendorOptions == other.VendorOptions
917     }
918 }
919 #[cfg(feature = "Win32_Foundation")]
920 impl ::std::cmp::Eq for DHCP_ALL_OPTIONS {}
921 #[cfg(feature = "Win32_Foundation")]
922 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTIONS {
923     type Abi = Self;
924     type DefaultType = Self;
925 }
926 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
927 #[repr(C)]
928 #[cfg(feature = "Win32_Foundation")]
929 pub struct DHCP_ALL_OPTIONS_0 {
930     pub Option: DHCP_OPTION,
931     pub VendorName: super::super::Foundation::PWSTR,
932     pub ClassName: super::super::Foundation::PWSTR,
933 }
934 #[cfg(feature = "Win32_Foundation")]
935 impl DHCP_ALL_OPTIONS_0 {}
936 #[cfg(feature = "Win32_Foundation")]
937 impl ::std::default::Default for DHCP_ALL_OPTIONS_0 {
default() -> Self938     fn default() -> Self {
939         unsafe { ::std::mem::zeroed() }
940     }
941 }
942 #[cfg(feature = "Win32_Foundation")]
943 impl ::std::fmt::Debug for DHCP_ALL_OPTIONS_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result944     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
945         fmt.debug_struct("_Anonymous_e__Struct").field("Option", &self.Option).field("VendorName", &self.VendorName).field("ClassName", &self.ClassName).finish()
946     }
947 }
948 #[cfg(feature = "Win32_Foundation")]
949 impl ::std::cmp::PartialEq for DHCP_ALL_OPTIONS_0 {
eq(&self, other: &Self) -> bool950     fn eq(&self, other: &Self) -> bool {
951         self.Option == other.Option && self.VendorName == other.VendorName && self.ClassName == other.ClassName
952     }
953 }
954 #[cfg(feature = "Win32_Foundation")]
955 impl ::std::cmp::Eq for DHCP_ALL_OPTIONS_0 {}
956 #[cfg(feature = "Win32_Foundation")]
957 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTIONS_0 {
958     type Abi = Self;
959     type DefaultType = Self;
960 }
961 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
962 #[repr(C)]
963 #[cfg(feature = "Win32_Foundation")]
964 pub struct DHCP_ALL_OPTION_VALUES {
965     pub Flags: u32,
966     pub NumElements: u32,
967     pub Options: *mut DHCP_ALL_OPTION_VALUES_0,
968 }
969 #[cfg(feature = "Win32_Foundation")]
970 impl DHCP_ALL_OPTION_VALUES {}
971 #[cfg(feature = "Win32_Foundation")]
972 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES {
default() -> Self973     fn default() -> Self {
974         unsafe { ::std::mem::zeroed() }
975     }
976 }
977 #[cfg(feature = "Win32_Foundation")]
978 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result979     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
980         fmt.debug_struct("DHCP_ALL_OPTION_VALUES").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
981     }
982 }
983 #[cfg(feature = "Win32_Foundation")]
984 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES {
eq(&self, other: &Self) -> bool985     fn eq(&self, other: &Self) -> bool {
986         self.Flags == other.Flags && self.NumElements == other.NumElements && self.Options == other.Options
987     }
988 }
989 #[cfg(feature = "Win32_Foundation")]
990 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES {}
991 #[cfg(feature = "Win32_Foundation")]
992 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES {
993     type Abi = Self;
994     type DefaultType = Self;
995 }
996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
997 #[repr(C)]
998 #[cfg(feature = "Win32_Foundation")]
999 pub struct DHCP_ALL_OPTION_VALUES_0 {
1000     pub ClassName: super::super::Foundation::PWSTR,
1001     pub VendorName: super::super::Foundation::PWSTR,
1002     pub IsVendor: super::super::Foundation::BOOL,
1003     pub OptionsArray: *mut DHCP_OPTION_VALUE_ARRAY,
1004 }
1005 #[cfg(feature = "Win32_Foundation")]
1006 impl DHCP_ALL_OPTION_VALUES_0 {}
1007 #[cfg(feature = "Win32_Foundation")]
1008 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_0 {
default() -> Self1009     fn default() -> Self {
1010         unsafe { ::std::mem::zeroed() }
1011     }
1012 }
1013 #[cfg(feature = "Win32_Foundation")]
1014 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1015     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1016         fmt.debug_struct("_Anonymous_e__Struct").field("ClassName", &self.ClassName).field("VendorName", &self.VendorName).field("IsVendor", &self.IsVendor).field("OptionsArray", &self.OptionsArray).finish()
1017     }
1018 }
1019 #[cfg(feature = "Win32_Foundation")]
1020 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_0 {
eq(&self, other: &Self) -> bool1021     fn eq(&self, other: &Self) -> bool {
1022         self.ClassName == other.ClassName && self.VendorName == other.VendorName && self.IsVendor == other.IsVendor && self.OptionsArray == other.OptionsArray
1023     }
1024 }
1025 #[cfg(feature = "Win32_Foundation")]
1026 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_0 {}
1027 #[cfg(feature = "Win32_Foundation")]
1028 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_0 {
1029     type Abi = Self;
1030     type DefaultType = Self;
1031 }
1032 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1033 #[repr(C)]
1034 #[cfg(feature = "Win32_Foundation")]
1035 pub struct DHCP_ALL_OPTION_VALUES_PB {
1036     pub Flags: u32,
1037     pub NumElements: u32,
1038     pub Options: *mut DHCP_ALL_OPTION_VALUES_PB_0,
1039 }
1040 #[cfg(feature = "Win32_Foundation")]
1041 impl DHCP_ALL_OPTION_VALUES_PB {}
1042 #[cfg(feature = "Win32_Foundation")]
1043 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_PB {
default() -> Self1044     fn default() -> Self {
1045         unsafe { ::std::mem::zeroed() }
1046     }
1047 }
1048 #[cfg(feature = "Win32_Foundation")]
1049 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_PB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1050     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1051         fmt.debug_struct("DHCP_ALL_OPTION_VALUES_PB").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
1052     }
1053 }
1054 #[cfg(feature = "Win32_Foundation")]
1055 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_PB {
eq(&self, other: &Self) -> bool1056     fn eq(&self, other: &Self) -> bool {
1057         self.Flags == other.Flags && self.NumElements == other.NumElements && self.Options == other.Options
1058     }
1059 }
1060 #[cfg(feature = "Win32_Foundation")]
1061 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_PB {}
1062 #[cfg(feature = "Win32_Foundation")]
1063 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_PB {
1064     type Abi = Self;
1065     type DefaultType = Self;
1066 }
1067 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1068 #[repr(C)]
1069 #[cfg(feature = "Win32_Foundation")]
1070 pub struct DHCP_ALL_OPTION_VALUES_PB_0 {
1071     pub PolicyName: super::super::Foundation::PWSTR,
1072     pub VendorName: super::super::Foundation::PWSTR,
1073     pub IsVendor: super::super::Foundation::BOOL,
1074     pub OptionsArray: *mut DHCP_OPTION_VALUE_ARRAY,
1075 }
1076 #[cfg(feature = "Win32_Foundation")]
1077 impl DHCP_ALL_OPTION_VALUES_PB_0 {}
1078 #[cfg(feature = "Win32_Foundation")]
1079 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_PB_0 {
default() -> Self1080     fn default() -> Self {
1081         unsafe { ::std::mem::zeroed() }
1082     }
1083 }
1084 #[cfg(feature = "Win32_Foundation")]
1085 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_PB_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1086     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1087         fmt.debug_struct("_Anonymous_e__Struct").field("PolicyName", &self.PolicyName).field("VendorName", &self.VendorName).field("IsVendor", &self.IsVendor).field("OptionsArray", &self.OptionsArray).finish()
1088     }
1089 }
1090 #[cfg(feature = "Win32_Foundation")]
1091 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_PB_0 {
eq(&self, other: &Self) -> bool1092     fn eq(&self, other: &Self) -> bool {
1093         self.PolicyName == other.PolicyName && self.VendorName == other.VendorName && self.IsVendor == other.IsVendor && self.OptionsArray == other.OptionsArray
1094     }
1095 }
1096 #[cfg(feature = "Win32_Foundation")]
1097 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_PB_0 {}
1098 #[cfg(feature = "Win32_Foundation")]
1099 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_PB_0 {
1100     type Abi = Self;
1101     type DefaultType = Self;
1102 }
1103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1104 #[repr(C)]
1105 #[cfg(feature = "Win32_Foundation")]
1106 pub struct DHCP_ATTRIB {
1107     pub DhcpAttribId: u32,
1108     pub DhcpAttribType: u32,
1109     pub Anonymous: DHCP_ATTRIB_0,
1110 }
1111 #[cfg(feature = "Win32_Foundation")]
1112 impl DHCP_ATTRIB {}
1113 #[cfg(feature = "Win32_Foundation")]
1114 impl ::std::default::Default for DHCP_ATTRIB {
default() -> Self1115     fn default() -> Self {
1116         unsafe { ::std::mem::zeroed() }
1117     }
1118 }
1119 #[cfg(feature = "Win32_Foundation")]
1120 impl ::std::cmp::PartialEq for DHCP_ATTRIB {
eq(&self, _other: &Self) -> bool1121     fn eq(&self, _other: &Self) -> bool {
1122         unimplemented!()
1123     }
1124 }
1125 #[cfg(feature = "Win32_Foundation")]
1126 impl ::std::cmp::Eq for DHCP_ATTRIB {}
1127 #[cfg(feature = "Win32_Foundation")]
1128 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB {
1129     type Abi = Self;
1130     type DefaultType = Self;
1131 }
1132 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1133 #[repr(C)]
1134 #[cfg(feature = "Win32_Foundation")]
1135 pub union DHCP_ATTRIB_0 {
1136     pub DhcpAttribBool: super::super::Foundation::BOOL,
1137     pub DhcpAttribUlong: u32,
1138 }
1139 #[cfg(feature = "Win32_Foundation")]
1140 impl DHCP_ATTRIB_0 {}
1141 #[cfg(feature = "Win32_Foundation")]
1142 impl ::std::default::Default for DHCP_ATTRIB_0 {
default() -> Self1143     fn default() -> Self {
1144         unsafe { ::std::mem::zeroed() }
1145     }
1146 }
1147 #[cfg(feature = "Win32_Foundation")]
1148 impl ::std::cmp::PartialEq for DHCP_ATTRIB_0 {
eq(&self, _other: &Self) -> bool1149     fn eq(&self, _other: &Self) -> bool {
1150         unimplemented!()
1151     }
1152 }
1153 #[cfg(feature = "Win32_Foundation")]
1154 impl ::std::cmp::Eq for DHCP_ATTRIB_0 {}
1155 #[cfg(feature = "Win32_Foundation")]
1156 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB_0 {
1157     type Abi = Self;
1158     type DefaultType = Self;
1159 }
1160 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1161 #[repr(C)]
1162 #[cfg(feature = "Win32_Foundation")]
1163 pub struct DHCP_ATTRIB_ARRAY {
1164     pub NumElements: u32,
1165     pub DhcpAttribs: *mut DHCP_ATTRIB,
1166 }
1167 #[cfg(feature = "Win32_Foundation")]
1168 impl DHCP_ATTRIB_ARRAY {}
1169 #[cfg(feature = "Win32_Foundation")]
1170 impl ::std::default::Default for DHCP_ATTRIB_ARRAY {
default() -> Self1171     fn default() -> Self {
1172         unsafe { ::std::mem::zeroed() }
1173     }
1174 }
1175 #[cfg(feature = "Win32_Foundation")]
1176 impl ::std::fmt::Debug for DHCP_ATTRIB_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1177     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1178         fmt.debug_struct("DHCP_ATTRIB_ARRAY").field("NumElements", &self.NumElements).field("DhcpAttribs", &self.DhcpAttribs).finish()
1179     }
1180 }
1181 #[cfg(feature = "Win32_Foundation")]
1182 impl ::std::cmp::PartialEq for DHCP_ATTRIB_ARRAY {
eq(&self, other: &Self) -> bool1183     fn eq(&self, other: &Self) -> bool {
1184         self.NumElements == other.NumElements && self.DhcpAttribs == other.DhcpAttribs
1185     }
1186 }
1187 #[cfg(feature = "Win32_Foundation")]
1188 impl ::std::cmp::Eq for DHCP_ATTRIB_ARRAY {}
1189 #[cfg(feature = "Win32_Foundation")]
1190 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB_ARRAY {
1191     type Abi = Self;
1192     type DefaultType = Self;
1193 }
1194 pub const DHCP_ATTRIB_BOOL_IS_ADMIN: u32 = 5u32;
1195 pub const DHCP_ATTRIB_BOOL_IS_BINDING_AWARE: u32 = 4u32;
1196 pub const DHCP_ATTRIB_BOOL_IS_DYNBOOTP: u32 = 2u32;
1197 pub const DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC: u32 = 3u32;
1198 pub const DHCP_ATTRIB_BOOL_IS_ROGUE: u32 = 1u32;
1199 pub const DHCP_ATTRIB_TYPE_BOOL: u32 = 1u32;
1200 pub const DHCP_ATTRIB_TYPE_ULONG: u32 = 2u32;
1201 pub const DHCP_ATTRIB_ULONG_RESTORE_STATUS: u32 = 6u32;
1202 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1203 #[repr(C)]
1204 pub struct DHCP_BINARY_DATA {
1205     pub DataLength: u32,
1206     pub Data: *mut u8,
1207 }
1208 impl DHCP_BINARY_DATA {}
1209 impl ::std::default::Default for DHCP_BINARY_DATA {
default() -> Self1210     fn default() -> Self {
1211         unsafe { ::std::mem::zeroed() }
1212     }
1213 }
1214 impl ::std::fmt::Debug for DHCP_BINARY_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1215     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1216         fmt.debug_struct("DHCP_BINARY_DATA").field("DataLength", &self.DataLength).field("Data", &self.Data).finish()
1217     }
1218 }
1219 impl ::std::cmp::PartialEq for DHCP_BINARY_DATA {
eq(&self, other: &Self) -> bool1220     fn eq(&self, other: &Self) -> bool {
1221         self.DataLength == other.DataLength && self.Data == other.Data
1222     }
1223 }
1224 impl ::std::cmp::Eq for DHCP_BINARY_DATA {}
1225 unsafe impl ::windows::runtime::Abi for DHCP_BINARY_DATA {
1226     type Abi = Self;
1227     type DefaultType = Self;
1228 }
1229 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1230 #[repr(C)]
1231 #[cfg(feature = "Win32_Foundation")]
1232 pub struct DHCP_BIND_ELEMENT {
1233     pub Flags: u32,
1234     pub fBoundToDHCPServer: super::super::Foundation::BOOL,
1235     pub AdapterPrimaryAddress: u32,
1236     pub AdapterSubnetAddress: u32,
1237     pub IfDescription: super::super::Foundation::PWSTR,
1238     pub IfIdSize: u32,
1239     pub IfId: *mut u8,
1240 }
1241 #[cfg(feature = "Win32_Foundation")]
1242 impl DHCP_BIND_ELEMENT {}
1243 #[cfg(feature = "Win32_Foundation")]
1244 impl ::std::default::Default for DHCP_BIND_ELEMENT {
default() -> Self1245     fn default() -> Self {
1246         unsafe { ::std::mem::zeroed() }
1247     }
1248 }
1249 #[cfg(feature = "Win32_Foundation")]
1250 impl ::std::fmt::Debug for DHCP_BIND_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1251     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1252         fmt.debug_struct("DHCP_BIND_ELEMENT")
1253             .field("Flags", &self.Flags)
1254             .field("fBoundToDHCPServer", &self.fBoundToDHCPServer)
1255             .field("AdapterPrimaryAddress", &self.AdapterPrimaryAddress)
1256             .field("AdapterSubnetAddress", &self.AdapterSubnetAddress)
1257             .field("IfDescription", &self.IfDescription)
1258             .field("IfIdSize", &self.IfIdSize)
1259             .field("IfId", &self.IfId)
1260             .finish()
1261     }
1262 }
1263 #[cfg(feature = "Win32_Foundation")]
1264 impl ::std::cmp::PartialEq for DHCP_BIND_ELEMENT {
eq(&self, other: &Self) -> bool1265     fn eq(&self, other: &Self) -> bool {
1266         self.Flags == other.Flags && self.fBoundToDHCPServer == other.fBoundToDHCPServer && self.AdapterPrimaryAddress == other.AdapterPrimaryAddress && self.AdapterSubnetAddress == other.AdapterSubnetAddress && self.IfDescription == other.IfDescription && self.IfIdSize == other.IfIdSize && self.IfId == other.IfId
1267     }
1268 }
1269 #[cfg(feature = "Win32_Foundation")]
1270 impl ::std::cmp::Eq for DHCP_BIND_ELEMENT {}
1271 #[cfg(feature = "Win32_Foundation")]
1272 unsafe impl ::windows::runtime::Abi for DHCP_BIND_ELEMENT {
1273     type Abi = Self;
1274     type DefaultType = Self;
1275 }
1276 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1277 #[repr(C)]
1278 #[cfg(feature = "Win32_Foundation")]
1279 pub struct DHCP_BIND_ELEMENT_ARRAY {
1280     pub NumElements: u32,
1281     pub Elements: *mut DHCP_BIND_ELEMENT,
1282 }
1283 #[cfg(feature = "Win32_Foundation")]
1284 impl DHCP_BIND_ELEMENT_ARRAY {}
1285 #[cfg(feature = "Win32_Foundation")]
1286 impl ::std::default::Default for DHCP_BIND_ELEMENT_ARRAY {
default() -> Self1287     fn default() -> Self {
1288         unsafe { ::std::mem::zeroed() }
1289     }
1290 }
1291 #[cfg(feature = "Win32_Foundation")]
1292 impl ::std::fmt::Debug for DHCP_BIND_ELEMENT_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1293     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1294         fmt.debug_struct("DHCP_BIND_ELEMENT_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
1295     }
1296 }
1297 #[cfg(feature = "Win32_Foundation")]
1298 impl ::std::cmp::PartialEq for DHCP_BIND_ELEMENT_ARRAY {
eq(&self, other: &Self) -> bool1299     fn eq(&self, other: &Self) -> bool {
1300         self.NumElements == other.NumElements && self.Elements == other.Elements
1301     }
1302 }
1303 #[cfg(feature = "Win32_Foundation")]
1304 impl ::std::cmp::Eq for DHCP_BIND_ELEMENT_ARRAY {}
1305 #[cfg(feature = "Win32_Foundation")]
1306 unsafe impl ::windows::runtime::Abi for DHCP_BIND_ELEMENT_ARRAY {
1307     type Abi = Self;
1308     type DefaultType = Self;
1309 }
1310 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1311 #[repr(C)]
1312 pub struct DHCP_BOOTP_IP_RANGE {
1313     pub StartAddress: u32,
1314     pub EndAddress: u32,
1315     pub BootpAllocated: u32,
1316     pub MaxBootpAllowed: u32,
1317 }
1318 impl DHCP_BOOTP_IP_RANGE {}
1319 impl ::std::default::Default for DHCP_BOOTP_IP_RANGE {
default() -> Self1320     fn default() -> Self {
1321         unsafe { ::std::mem::zeroed() }
1322     }
1323 }
1324 impl ::std::fmt::Debug for DHCP_BOOTP_IP_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1325     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1326         fmt.debug_struct("DHCP_BOOTP_IP_RANGE").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).field("BootpAllocated", &self.BootpAllocated).field("MaxBootpAllowed", &self.MaxBootpAllowed).finish()
1327     }
1328 }
1329 impl ::std::cmp::PartialEq for DHCP_BOOTP_IP_RANGE {
eq(&self, other: &Self) -> bool1330     fn eq(&self, other: &Self) -> bool {
1331         self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress && self.BootpAllocated == other.BootpAllocated && self.MaxBootpAllowed == other.MaxBootpAllowed
1332     }
1333 }
1334 impl ::std::cmp::Eq for DHCP_BOOTP_IP_RANGE {}
1335 unsafe impl ::windows::runtime::Abi for DHCP_BOOTP_IP_RANGE {
1336     type Abi = Self;
1337     type DefaultType = Self;
1338 }
1339 #[derive(:: std :: clone :: Clone)]
1340 #[repr(C)]
1341 #[cfg(feature = "Win32_Foundation")]
1342 pub struct DHCP_CALLOUT_TABLE {
1343     pub DhcpControlHook: ::std::option::Option<LPDHCP_CONTROL>,
1344     pub DhcpNewPktHook: ::std::option::Option<LPDHCP_NEWPKT>,
1345     pub DhcpPktDropHook: ::std::option::Option<LPDHCP_DROP_SEND>,
1346     pub DhcpPktSendHook: ::std::option::Option<LPDHCP_DROP_SEND>,
1347     pub DhcpAddressDelHook: ::std::option::Option<LPDHCP_PROB>,
1348     pub DhcpAddressOfferHook: ::std::option::Option<LPDHCP_GIVE_ADDRESS>,
1349     pub DhcpHandleOptionsHook: ::std::option::Option<LPDHCP_HANDLE_OPTIONS>,
1350     pub DhcpDeleteClientHook: ::std::option::Option<LPDHCP_DELETE_CLIENT>,
1351     pub DhcpExtensionHook: *mut ::std::ffi::c_void,
1352     pub DhcpReservedHook: *mut ::std::ffi::c_void,
1353 }
1354 #[cfg(feature = "Win32_Foundation")]
1355 impl DHCP_CALLOUT_TABLE {}
1356 #[cfg(feature = "Win32_Foundation")]
1357 impl ::std::default::Default for DHCP_CALLOUT_TABLE {
default() -> Self1358     fn default() -> Self {
1359         unsafe { ::std::mem::zeroed() }
1360     }
1361 }
1362 #[cfg(feature = "Win32_Foundation")]
1363 impl ::std::fmt::Debug for DHCP_CALLOUT_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1364     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1365         fmt.debug_struct("DHCP_CALLOUT_TABLE").field("DhcpExtensionHook", &self.DhcpExtensionHook).field("DhcpReservedHook", &self.DhcpReservedHook).finish()
1366     }
1367 }
1368 #[cfg(feature = "Win32_Foundation")]
1369 impl ::std::cmp::PartialEq for DHCP_CALLOUT_TABLE {
eq(&self, other: &Self) -> bool1370     fn eq(&self, other: &Self) -> bool {
1371         self.DhcpControlHook.map(|f| f as usize) == other.DhcpControlHook.map(|f| f as usize)
1372             && self.DhcpNewPktHook.map(|f| f as usize) == other.DhcpNewPktHook.map(|f| f as usize)
1373             && self.DhcpPktDropHook.map(|f| f as usize) == other.DhcpPktDropHook.map(|f| f as usize)
1374             && self.DhcpPktSendHook.map(|f| f as usize) == other.DhcpPktSendHook.map(|f| f as usize)
1375             && self.DhcpAddressDelHook.map(|f| f as usize) == other.DhcpAddressDelHook.map(|f| f as usize)
1376             && self.DhcpAddressOfferHook.map(|f| f as usize) == other.DhcpAddressOfferHook.map(|f| f as usize)
1377             && self.DhcpHandleOptionsHook.map(|f| f as usize) == other.DhcpHandleOptionsHook.map(|f| f as usize)
1378             && self.DhcpDeleteClientHook.map(|f| f as usize) == other.DhcpDeleteClientHook.map(|f| f as usize)
1379             && self.DhcpExtensionHook == other.DhcpExtensionHook
1380             && self.DhcpReservedHook == other.DhcpReservedHook
1381     }
1382 }
1383 #[cfg(feature = "Win32_Foundation")]
1384 impl ::std::cmp::Eq for DHCP_CALLOUT_TABLE {}
1385 #[cfg(feature = "Win32_Foundation")]
1386 unsafe impl ::windows::runtime::Abi for DHCP_CALLOUT_TABLE {
1387     type Abi = ::std::mem::ManuallyDrop<Self>;
1388     type DefaultType = Self;
1389 }
1390 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1391 #[repr(C)]
1392 #[cfg(feature = "Win32_Foundation")]
1393 pub struct DHCP_CLASS_INFO {
1394     pub ClassName: super::super::Foundation::PWSTR,
1395     pub ClassComment: super::super::Foundation::PWSTR,
1396     pub ClassDataLength: u32,
1397     pub IsVendor: super::super::Foundation::BOOL,
1398     pub Flags: u32,
1399     pub ClassData: *mut u8,
1400 }
1401 #[cfg(feature = "Win32_Foundation")]
1402 impl DHCP_CLASS_INFO {}
1403 #[cfg(feature = "Win32_Foundation")]
1404 impl ::std::default::Default for DHCP_CLASS_INFO {
default() -> Self1405     fn default() -> Self {
1406         unsafe { ::std::mem::zeroed() }
1407     }
1408 }
1409 #[cfg(feature = "Win32_Foundation")]
1410 impl ::std::fmt::Debug for DHCP_CLASS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1411     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1412         fmt.debug_struct("DHCP_CLASS_INFO").field("ClassName", &self.ClassName).field("ClassComment", &self.ClassComment).field("ClassDataLength", &self.ClassDataLength).field("IsVendor", &self.IsVendor).field("Flags", &self.Flags).field("ClassData", &self.ClassData).finish()
1413     }
1414 }
1415 #[cfg(feature = "Win32_Foundation")]
1416 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO {
eq(&self, other: &Self) -> bool1417     fn eq(&self, other: &Self) -> bool {
1418         self.ClassName == other.ClassName && self.ClassComment == other.ClassComment && self.ClassDataLength == other.ClassDataLength && self.IsVendor == other.IsVendor && self.Flags == other.Flags && self.ClassData == other.ClassData
1419     }
1420 }
1421 #[cfg(feature = "Win32_Foundation")]
1422 impl ::std::cmp::Eq for DHCP_CLASS_INFO {}
1423 #[cfg(feature = "Win32_Foundation")]
1424 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO {
1425     type Abi = Self;
1426     type DefaultType = Self;
1427 }
1428 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1429 #[repr(C)]
1430 #[cfg(feature = "Win32_Foundation")]
1431 pub struct DHCP_CLASS_INFO_ARRAY {
1432     pub NumElements: u32,
1433     pub Classes: *mut DHCP_CLASS_INFO,
1434 }
1435 #[cfg(feature = "Win32_Foundation")]
1436 impl DHCP_CLASS_INFO_ARRAY {}
1437 #[cfg(feature = "Win32_Foundation")]
1438 impl ::std::default::Default for DHCP_CLASS_INFO_ARRAY {
default() -> Self1439     fn default() -> Self {
1440         unsafe { ::std::mem::zeroed() }
1441     }
1442 }
1443 #[cfg(feature = "Win32_Foundation")]
1444 impl ::std::fmt::Debug for DHCP_CLASS_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1445     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1446         fmt.debug_struct("DHCP_CLASS_INFO_ARRAY").field("NumElements", &self.NumElements).field("Classes", &self.Classes).finish()
1447     }
1448 }
1449 #[cfg(feature = "Win32_Foundation")]
1450 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_ARRAY {
eq(&self, other: &Self) -> bool1451     fn eq(&self, other: &Self) -> bool {
1452         self.NumElements == other.NumElements && self.Classes == other.Classes
1453     }
1454 }
1455 #[cfg(feature = "Win32_Foundation")]
1456 impl ::std::cmp::Eq for DHCP_CLASS_INFO_ARRAY {}
1457 #[cfg(feature = "Win32_Foundation")]
1458 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_ARRAY {
1459     type Abi = Self;
1460     type DefaultType = Self;
1461 }
1462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1463 #[repr(C)]
1464 #[cfg(feature = "Win32_Foundation")]
1465 pub struct DHCP_CLASS_INFO_ARRAY_V6 {
1466     pub NumElements: u32,
1467     pub Classes: *mut DHCP_CLASS_INFO_V6,
1468 }
1469 #[cfg(feature = "Win32_Foundation")]
1470 impl DHCP_CLASS_INFO_ARRAY_V6 {}
1471 #[cfg(feature = "Win32_Foundation")]
1472 impl ::std::default::Default for DHCP_CLASS_INFO_ARRAY_V6 {
default() -> Self1473     fn default() -> Self {
1474         unsafe { ::std::mem::zeroed() }
1475     }
1476 }
1477 #[cfg(feature = "Win32_Foundation")]
1478 impl ::std::fmt::Debug for DHCP_CLASS_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1479     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1480         fmt.debug_struct("DHCP_CLASS_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Classes", &self.Classes).finish()
1481     }
1482 }
1483 #[cfg(feature = "Win32_Foundation")]
1484 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool1485     fn eq(&self, other: &Self) -> bool {
1486         self.NumElements == other.NumElements && self.Classes == other.Classes
1487     }
1488 }
1489 #[cfg(feature = "Win32_Foundation")]
1490 impl ::std::cmp::Eq for DHCP_CLASS_INFO_ARRAY_V6 {}
1491 #[cfg(feature = "Win32_Foundation")]
1492 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_ARRAY_V6 {
1493     type Abi = Self;
1494     type DefaultType = Self;
1495 }
1496 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1497 #[repr(C)]
1498 #[cfg(feature = "Win32_Foundation")]
1499 pub struct DHCP_CLASS_INFO_V6 {
1500     pub ClassName: super::super::Foundation::PWSTR,
1501     pub ClassComment: super::super::Foundation::PWSTR,
1502     pub ClassDataLength: u32,
1503     pub IsVendor: super::super::Foundation::BOOL,
1504     pub EnterpriseNumber: u32,
1505     pub Flags: u32,
1506     pub ClassData: *mut u8,
1507 }
1508 #[cfg(feature = "Win32_Foundation")]
1509 impl DHCP_CLASS_INFO_V6 {}
1510 #[cfg(feature = "Win32_Foundation")]
1511 impl ::std::default::Default for DHCP_CLASS_INFO_V6 {
default() -> Self1512     fn default() -> Self {
1513         unsafe { ::std::mem::zeroed() }
1514     }
1515 }
1516 #[cfg(feature = "Win32_Foundation")]
1517 impl ::std::fmt::Debug for DHCP_CLASS_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1518     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1519         fmt.debug_struct("DHCP_CLASS_INFO_V6")
1520             .field("ClassName", &self.ClassName)
1521             .field("ClassComment", &self.ClassComment)
1522             .field("ClassDataLength", &self.ClassDataLength)
1523             .field("IsVendor", &self.IsVendor)
1524             .field("EnterpriseNumber", &self.EnterpriseNumber)
1525             .field("Flags", &self.Flags)
1526             .field("ClassData", &self.ClassData)
1527             .finish()
1528     }
1529 }
1530 #[cfg(feature = "Win32_Foundation")]
1531 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_V6 {
eq(&self, other: &Self) -> bool1532     fn eq(&self, other: &Self) -> bool {
1533         self.ClassName == other.ClassName && self.ClassComment == other.ClassComment && self.ClassDataLength == other.ClassDataLength && self.IsVendor == other.IsVendor && self.EnterpriseNumber == other.EnterpriseNumber && self.Flags == other.Flags && self.ClassData == other.ClassData
1534     }
1535 }
1536 #[cfg(feature = "Win32_Foundation")]
1537 impl ::std::cmp::Eq for DHCP_CLASS_INFO_V6 {}
1538 #[cfg(feature = "Win32_Foundation")]
1539 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_V6 {
1540     type Abi = Self;
1541     type DefaultType = Self;
1542 }
1543 pub const DHCP_CLIENT_BOOTP: u32 = 805306371u32;
1544 pub const DHCP_CLIENT_DHCP: u32 = 805306372u32;
1545 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1546 #[repr(C)]
1547 #[cfg(feature = "Win32_Foundation")]
1548 pub struct DHCP_CLIENT_FILTER_STATUS_INFO {
1549     pub ClientIpAddress: u32,
1550     pub SubnetMask: u32,
1551     pub ClientHardwareAddress: DHCP_BINARY_DATA,
1552     pub ClientName: super::super::Foundation::PWSTR,
1553     pub ClientComment: super::super::Foundation::PWSTR,
1554     pub ClientLeaseExpires: DATE_TIME,
1555     pub OwnerHost: DHCP_HOST_INFO,
1556     pub bClientType: u8,
1557     pub AddressState: u8,
1558     pub Status: QuarantineStatus,
1559     pub ProbationEnds: DATE_TIME,
1560     pub QuarantineCapable: super::super::Foundation::BOOL,
1561     pub FilterStatus: u32,
1562 }
1563 #[cfg(feature = "Win32_Foundation")]
1564 impl DHCP_CLIENT_FILTER_STATUS_INFO {}
1565 #[cfg(feature = "Win32_Foundation")]
1566 impl ::std::default::Default for DHCP_CLIENT_FILTER_STATUS_INFO {
default() -> Self1567     fn default() -> Self {
1568         unsafe { ::std::mem::zeroed() }
1569     }
1570 }
1571 #[cfg(feature = "Win32_Foundation")]
1572 impl ::std::fmt::Debug for DHCP_CLIENT_FILTER_STATUS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1573     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1574         fmt.debug_struct("DHCP_CLIENT_FILTER_STATUS_INFO")
1575             .field("ClientIpAddress", &self.ClientIpAddress)
1576             .field("SubnetMask", &self.SubnetMask)
1577             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1578             .field("ClientName", &self.ClientName)
1579             .field("ClientComment", &self.ClientComment)
1580             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1581             .field("OwnerHost", &self.OwnerHost)
1582             .field("bClientType", &self.bClientType)
1583             .field("AddressState", &self.AddressState)
1584             .field("Status", &self.Status)
1585             .field("ProbationEnds", &self.ProbationEnds)
1586             .field("QuarantineCapable", &self.QuarantineCapable)
1587             .field("FilterStatus", &self.FilterStatus)
1588             .finish()
1589     }
1590 }
1591 #[cfg(feature = "Win32_Foundation")]
1592 impl ::std::cmp::PartialEq for DHCP_CLIENT_FILTER_STATUS_INFO {
eq(&self, other: &Self) -> bool1593     fn eq(&self, other: &Self) -> bool {
1594         self.ClientIpAddress == other.ClientIpAddress
1595             && self.SubnetMask == other.SubnetMask
1596             && self.ClientHardwareAddress == other.ClientHardwareAddress
1597             && self.ClientName == other.ClientName
1598             && self.ClientComment == other.ClientComment
1599             && self.ClientLeaseExpires == other.ClientLeaseExpires
1600             && self.OwnerHost == other.OwnerHost
1601             && self.bClientType == other.bClientType
1602             && self.AddressState == other.AddressState
1603             && self.Status == other.Status
1604             && self.ProbationEnds == other.ProbationEnds
1605             && self.QuarantineCapable == other.QuarantineCapable
1606             && self.FilterStatus == other.FilterStatus
1607     }
1608 }
1609 #[cfg(feature = "Win32_Foundation")]
1610 impl ::std::cmp::Eq for DHCP_CLIENT_FILTER_STATUS_INFO {}
1611 #[cfg(feature = "Win32_Foundation")]
1612 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_FILTER_STATUS_INFO {
1613     type Abi = Self;
1614     type DefaultType = Self;
1615 }
1616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1617 #[repr(C)]
1618 #[cfg(feature = "Win32_Foundation")]
1619 pub struct DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
1620     pub NumElements: u32,
1621     pub Clients: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO,
1622 }
1623 #[cfg(feature = "Win32_Foundation")]
1624 impl DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {}
1625 #[cfg(feature = "Win32_Foundation")]
1626 impl ::std::default::Default for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
default() -> Self1627     fn default() -> Self {
1628         unsafe { ::std::mem::zeroed() }
1629     }
1630 }
1631 #[cfg(feature = "Win32_Foundation")]
1632 impl ::std::fmt::Debug for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1633     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1634         fmt.debug_struct("DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1635     }
1636 }
1637 #[cfg(feature = "Win32_Foundation")]
1638 impl ::std::cmp::PartialEq for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
eq(&self, other: &Self) -> bool1639     fn eq(&self, other: &Self) -> bool {
1640         self.NumElements == other.NumElements && self.Clients == other.Clients
1641     }
1642 }
1643 #[cfg(feature = "Win32_Foundation")]
1644 impl ::std::cmp::Eq for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {}
1645 #[cfg(feature = "Win32_Foundation")]
1646 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
1647     type Abi = Self;
1648     type DefaultType = Self;
1649 }
1650 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1651 #[repr(C)]
1652 #[cfg(feature = "Win32_Foundation")]
1653 pub struct DHCP_CLIENT_INFO {
1654     pub ClientIpAddress: u32,
1655     pub SubnetMask: u32,
1656     pub ClientHardwareAddress: DHCP_BINARY_DATA,
1657     pub ClientName: super::super::Foundation::PWSTR,
1658     pub ClientComment: super::super::Foundation::PWSTR,
1659     pub ClientLeaseExpires: DATE_TIME,
1660     pub OwnerHost: DHCP_HOST_INFO,
1661 }
1662 #[cfg(feature = "Win32_Foundation")]
1663 impl DHCP_CLIENT_INFO {}
1664 #[cfg(feature = "Win32_Foundation")]
1665 impl ::std::default::Default for DHCP_CLIENT_INFO {
default() -> Self1666     fn default() -> Self {
1667         unsafe { ::std::mem::zeroed() }
1668     }
1669 }
1670 #[cfg(feature = "Win32_Foundation")]
1671 impl ::std::fmt::Debug for DHCP_CLIENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1672     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1673         fmt.debug_struct("DHCP_CLIENT_INFO")
1674             .field("ClientIpAddress", &self.ClientIpAddress)
1675             .field("SubnetMask", &self.SubnetMask)
1676             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1677             .field("ClientName", &self.ClientName)
1678             .field("ClientComment", &self.ClientComment)
1679             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1680             .field("OwnerHost", &self.OwnerHost)
1681             .finish()
1682     }
1683 }
1684 #[cfg(feature = "Win32_Foundation")]
1685 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO {
eq(&self, other: &Self) -> bool1686     fn eq(&self, other: &Self) -> bool {
1687         self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost
1688     }
1689 }
1690 #[cfg(feature = "Win32_Foundation")]
1691 impl ::std::cmp::Eq for DHCP_CLIENT_INFO {}
1692 #[cfg(feature = "Win32_Foundation")]
1693 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO {
1694     type Abi = Self;
1695     type DefaultType = Self;
1696 }
1697 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1698 #[repr(C)]
1699 #[cfg(feature = "Win32_Foundation")]
1700 pub struct DHCP_CLIENT_INFO_ARRAY {
1701     pub NumElements: u32,
1702     pub Clients: *mut *mut DHCP_CLIENT_INFO,
1703 }
1704 #[cfg(feature = "Win32_Foundation")]
1705 impl DHCP_CLIENT_INFO_ARRAY {}
1706 #[cfg(feature = "Win32_Foundation")]
1707 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY {
default() -> Self1708     fn default() -> Self {
1709         unsafe { ::std::mem::zeroed() }
1710     }
1711 }
1712 #[cfg(feature = "Win32_Foundation")]
1713 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1714     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1715         fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1716     }
1717 }
1718 #[cfg(feature = "Win32_Foundation")]
1719 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool1720     fn eq(&self, other: &Self) -> bool {
1721         self.NumElements == other.NumElements && self.Clients == other.Clients
1722     }
1723 }
1724 #[cfg(feature = "Win32_Foundation")]
1725 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY {}
1726 #[cfg(feature = "Win32_Foundation")]
1727 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY {
1728     type Abi = Self;
1729     type DefaultType = Self;
1730 }
1731 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1732 #[repr(C)]
1733 #[cfg(feature = "Win32_Foundation")]
1734 pub struct DHCP_CLIENT_INFO_ARRAY_V4 {
1735     pub NumElements: u32,
1736     pub Clients: *mut *mut DHCP_CLIENT_INFO_V4,
1737 }
1738 #[cfg(feature = "Win32_Foundation")]
1739 impl DHCP_CLIENT_INFO_ARRAY_V4 {}
1740 #[cfg(feature = "Win32_Foundation")]
1741 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V4 {
default() -> Self1742     fn default() -> Self {
1743         unsafe { ::std::mem::zeroed() }
1744     }
1745 }
1746 #[cfg(feature = "Win32_Foundation")]
1747 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1748     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1749         fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V4").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1750     }
1751 }
1752 #[cfg(feature = "Win32_Foundation")]
1753 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V4 {
eq(&self, other: &Self) -> bool1754     fn eq(&self, other: &Self) -> bool {
1755         self.NumElements == other.NumElements && self.Clients == other.Clients
1756     }
1757 }
1758 #[cfg(feature = "Win32_Foundation")]
1759 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V4 {}
1760 #[cfg(feature = "Win32_Foundation")]
1761 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V4 {
1762     type Abi = Self;
1763     type DefaultType = Self;
1764 }
1765 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1766 #[repr(C)]
1767 #[cfg(feature = "Win32_Foundation")]
1768 pub struct DHCP_CLIENT_INFO_ARRAY_V5 {
1769     pub NumElements: u32,
1770     pub Clients: *mut *mut DHCP_CLIENT_INFO_V5,
1771 }
1772 #[cfg(feature = "Win32_Foundation")]
1773 impl DHCP_CLIENT_INFO_ARRAY_V5 {}
1774 #[cfg(feature = "Win32_Foundation")]
1775 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V5 {
default() -> Self1776     fn default() -> Self {
1777         unsafe { ::std::mem::zeroed() }
1778     }
1779 }
1780 #[cfg(feature = "Win32_Foundation")]
1781 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1782     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1783         fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V5").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1784     }
1785 }
1786 #[cfg(feature = "Win32_Foundation")]
1787 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V5 {
eq(&self, other: &Self) -> bool1788     fn eq(&self, other: &Self) -> bool {
1789         self.NumElements == other.NumElements && self.Clients == other.Clients
1790     }
1791 }
1792 #[cfg(feature = "Win32_Foundation")]
1793 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V5 {}
1794 #[cfg(feature = "Win32_Foundation")]
1795 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V5 {
1796     type Abi = Self;
1797     type DefaultType = Self;
1798 }
1799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1800 #[repr(C)]
1801 #[cfg(feature = "Win32_Foundation")]
1802 pub struct DHCP_CLIENT_INFO_ARRAY_V6 {
1803     pub NumElements: u32,
1804     pub Clients: *mut *mut DHCP_CLIENT_INFO_V6,
1805 }
1806 #[cfg(feature = "Win32_Foundation")]
1807 impl DHCP_CLIENT_INFO_ARRAY_V6 {}
1808 #[cfg(feature = "Win32_Foundation")]
1809 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V6 {
default() -> Self1810     fn default() -> Self {
1811         unsafe { ::std::mem::zeroed() }
1812     }
1813 }
1814 #[cfg(feature = "Win32_Foundation")]
1815 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1816     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1817         fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1818     }
1819 }
1820 #[cfg(feature = "Win32_Foundation")]
1821 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool1822     fn eq(&self, other: &Self) -> bool {
1823         self.NumElements == other.NumElements && self.Clients == other.Clients
1824     }
1825 }
1826 #[cfg(feature = "Win32_Foundation")]
1827 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V6 {}
1828 #[cfg(feature = "Win32_Foundation")]
1829 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V6 {
1830     type Abi = Self;
1831     type DefaultType = Self;
1832 }
1833 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1834 #[repr(C)]
1835 #[cfg(feature = "Win32_Foundation")]
1836 pub struct DHCP_CLIENT_INFO_ARRAY_VQ {
1837     pub NumElements: u32,
1838     pub Clients: *mut *mut DHCP_CLIENT_INFO_VQ,
1839 }
1840 #[cfg(feature = "Win32_Foundation")]
1841 impl DHCP_CLIENT_INFO_ARRAY_VQ {}
1842 #[cfg(feature = "Win32_Foundation")]
1843 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_VQ {
default() -> Self1844     fn default() -> Self {
1845         unsafe { ::std::mem::zeroed() }
1846     }
1847 }
1848 #[cfg(feature = "Win32_Foundation")]
1849 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1850     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1851         fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_VQ").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1852     }
1853 }
1854 #[cfg(feature = "Win32_Foundation")]
1855 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_VQ {
eq(&self, other: &Self) -> bool1856     fn eq(&self, other: &Self) -> bool {
1857         self.NumElements == other.NumElements && self.Clients == other.Clients
1858     }
1859 }
1860 #[cfg(feature = "Win32_Foundation")]
1861 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_VQ {}
1862 #[cfg(feature = "Win32_Foundation")]
1863 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_VQ {
1864     type Abi = Self;
1865     type DefaultType = Self;
1866 }
1867 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1868 #[repr(C)]
1869 #[cfg(feature = "Win32_Foundation")]
1870 pub struct DHCP_CLIENT_INFO_EX {
1871     pub ClientIpAddress: u32,
1872     pub SubnetMask: u32,
1873     pub ClientHardwareAddress: DHCP_BINARY_DATA,
1874     pub ClientName: super::super::Foundation::PWSTR,
1875     pub ClientComment: super::super::Foundation::PWSTR,
1876     pub ClientLeaseExpires: DATE_TIME,
1877     pub OwnerHost: DHCP_HOST_INFO,
1878     pub bClientType: u8,
1879     pub AddressState: u8,
1880     pub Status: QuarantineStatus,
1881     pub ProbationEnds: DATE_TIME,
1882     pub QuarantineCapable: super::super::Foundation::BOOL,
1883     pub FilterStatus: u32,
1884     pub PolicyName: super::super::Foundation::PWSTR,
1885     pub Properties: *mut DHCP_PROPERTY_ARRAY,
1886 }
1887 #[cfg(feature = "Win32_Foundation")]
1888 impl DHCP_CLIENT_INFO_EX {}
1889 #[cfg(feature = "Win32_Foundation")]
1890 impl ::std::default::Default for DHCP_CLIENT_INFO_EX {
default() -> Self1891     fn default() -> Self {
1892         unsafe { ::std::mem::zeroed() }
1893     }
1894 }
1895 #[cfg(feature = "Win32_Foundation")]
1896 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1897     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1898         fmt.debug_struct("DHCP_CLIENT_INFO_EX")
1899             .field("ClientIpAddress", &self.ClientIpAddress)
1900             .field("SubnetMask", &self.SubnetMask)
1901             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1902             .field("ClientName", &self.ClientName)
1903             .field("ClientComment", &self.ClientComment)
1904             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1905             .field("OwnerHost", &self.OwnerHost)
1906             .field("bClientType", &self.bClientType)
1907             .field("AddressState", &self.AddressState)
1908             .field("Status", &self.Status)
1909             .field("ProbationEnds", &self.ProbationEnds)
1910             .field("QuarantineCapable", &self.QuarantineCapable)
1911             .field("FilterStatus", &self.FilterStatus)
1912             .field("PolicyName", &self.PolicyName)
1913             .field("Properties", &self.Properties)
1914             .finish()
1915     }
1916 }
1917 #[cfg(feature = "Win32_Foundation")]
1918 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_EX {
eq(&self, other: &Self) -> bool1919     fn eq(&self, other: &Self) -> bool {
1920         self.ClientIpAddress == other.ClientIpAddress
1921             && self.SubnetMask == other.SubnetMask
1922             && self.ClientHardwareAddress == other.ClientHardwareAddress
1923             && self.ClientName == other.ClientName
1924             && self.ClientComment == other.ClientComment
1925             && self.ClientLeaseExpires == other.ClientLeaseExpires
1926             && self.OwnerHost == other.OwnerHost
1927             && self.bClientType == other.bClientType
1928             && self.AddressState == other.AddressState
1929             && self.Status == other.Status
1930             && self.ProbationEnds == other.ProbationEnds
1931             && self.QuarantineCapable == other.QuarantineCapable
1932             && self.FilterStatus == other.FilterStatus
1933             && self.PolicyName == other.PolicyName
1934             && self.Properties == other.Properties
1935     }
1936 }
1937 #[cfg(feature = "Win32_Foundation")]
1938 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_EX {}
1939 #[cfg(feature = "Win32_Foundation")]
1940 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_EX {
1941     type Abi = Self;
1942     type DefaultType = Self;
1943 }
1944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1945 #[repr(C)]
1946 #[cfg(feature = "Win32_Foundation")]
1947 pub struct DHCP_CLIENT_INFO_EX_ARRAY {
1948     pub NumElements: u32,
1949     pub Clients: *mut *mut DHCP_CLIENT_INFO_EX,
1950 }
1951 #[cfg(feature = "Win32_Foundation")]
1952 impl DHCP_CLIENT_INFO_EX_ARRAY {}
1953 #[cfg(feature = "Win32_Foundation")]
1954 impl ::std::default::Default for DHCP_CLIENT_INFO_EX_ARRAY {
default() -> Self1955     fn default() -> Self {
1956         unsafe { ::std::mem::zeroed() }
1957     }
1958 }
1959 #[cfg(feature = "Win32_Foundation")]
1960 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_EX_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1961     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1962         fmt.debug_struct("DHCP_CLIENT_INFO_EX_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1963     }
1964 }
1965 #[cfg(feature = "Win32_Foundation")]
1966 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_EX_ARRAY {
eq(&self, other: &Self) -> bool1967     fn eq(&self, other: &Self) -> bool {
1968         self.NumElements == other.NumElements && self.Clients == other.Clients
1969     }
1970 }
1971 #[cfg(feature = "Win32_Foundation")]
1972 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_EX_ARRAY {}
1973 #[cfg(feature = "Win32_Foundation")]
1974 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_EX_ARRAY {
1975     type Abi = Self;
1976     type DefaultType = Self;
1977 }
1978 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1979 #[repr(C)]
1980 #[cfg(feature = "Win32_Foundation")]
1981 pub struct DHCP_CLIENT_INFO_PB {
1982     pub ClientIpAddress: u32,
1983     pub SubnetMask: u32,
1984     pub ClientHardwareAddress: DHCP_BINARY_DATA,
1985     pub ClientName: super::super::Foundation::PWSTR,
1986     pub ClientComment: super::super::Foundation::PWSTR,
1987     pub ClientLeaseExpires: DATE_TIME,
1988     pub OwnerHost: DHCP_HOST_INFO,
1989     pub bClientType: u8,
1990     pub AddressState: u8,
1991     pub Status: QuarantineStatus,
1992     pub ProbationEnds: DATE_TIME,
1993     pub QuarantineCapable: super::super::Foundation::BOOL,
1994     pub FilterStatus: u32,
1995     pub PolicyName: super::super::Foundation::PWSTR,
1996 }
1997 #[cfg(feature = "Win32_Foundation")]
1998 impl DHCP_CLIENT_INFO_PB {}
1999 #[cfg(feature = "Win32_Foundation")]
2000 impl ::std::default::Default for DHCP_CLIENT_INFO_PB {
default() -> Self2001     fn default() -> Self {
2002         unsafe { ::std::mem::zeroed() }
2003     }
2004 }
2005 #[cfg(feature = "Win32_Foundation")]
2006 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_PB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2007     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2008         fmt.debug_struct("DHCP_CLIENT_INFO_PB")
2009             .field("ClientIpAddress", &self.ClientIpAddress)
2010             .field("SubnetMask", &self.SubnetMask)
2011             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2012             .field("ClientName", &self.ClientName)
2013             .field("ClientComment", &self.ClientComment)
2014             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2015             .field("OwnerHost", &self.OwnerHost)
2016             .field("bClientType", &self.bClientType)
2017             .field("AddressState", &self.AddressState)
2018             .field("Status", &self.Status)
2019             .field("ProbationEnds", &self.ProbationEnds)
2020             .field("QuarantineCapable", &self.QuarantineCapable)
2021             .field("FilterStatus", &self.FilterStatus)
2022             .field("PolicyName", &self.PolicyName)
2023             .finish()
2024     }
2025 }
2026 #[cfg(feature = "Win32_Foundation")]
2027 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_PB {
eq(&self, other: &Self) -> bool2028     fn eq(&self, other: &Self) -> bool {
2029         self.ClientIpAddress == other.ClientIpAddress
2030             && self.SubnetMask == other.SubnetMask
2031             && self.ClientHardwareAddress == other.ClientHardwareAddress
2032             && self.ClientName == other.ClientName
2033             && self.ClientComment == other.ClientComment
2034             && self.ClientLeaseExpires == other.ClientLeaseExpires
2035             && self.OwnerHost == other.OwnerHost
2036             && self.bClientType == other.bClientType
2037             && self.AddressState == other.AddressState
2038             && self.Status == other.Status
2039             && self.ProbationEnds == other.ProbationEnds
2040             && self.QuarantineCapable == other.QuarantineCapable
2041             && self.FilterStatus == other.FilterStatus
2042             && self.PolicyName == other.PolicyName
2043     }
2044 }
2045 #[cfg(feature = "Win32_Foundation")]
2046 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_PB {}
2047 #[cfg(feature = "Win32_Foundation")]
2048 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_PB {
2049     type Abi = Self;
2050     type DefaultType = Self;
2051 }
2052 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2053 #[repr(C)]
2054 #[cfg(feature = "Win32_Foundation")]
2055 pub struct DHCP_CLIENT_INFO_PB_ARRAY {
2056     pub NumElements: u32,
2057     pub Clients: *mut *mut DHCP_CLIENT_INFO_PB,
2058 }
2059 #[cfg(feature = "Win32_Foundation")]
2060 impl DHCP_CLIENT_INFO_PB_ARRAY {}
2061 #[cfg(feature = "Win32_Foundation")]
2062 impl ::std::default::Default for DHCP_CLIENT_INFO_PB_ARRAY {
default() -> Self2063     fn default() -> Self {
2064         unsafe { ::std::mem::zeroed() }
2065     }
2066 }
2067 #[cfg(feature = "Win32_Foundation")]
2068 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_PB_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2069     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2070         fmt.debug_struct("DHCP_CLIENT_INFO_PB_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
2071     }
2072 }
2073 #[cfg(feature = "Win32_Foundation")]
2074 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_PB_ARRAY {
eq(&self, other: &Self) -> bool2075     fn eq(&self, other: &Self) -> bool {
2076         self.NumElements == other.NumElements && self.Clients == other.Clients
2077     }
2078 }
2079 #[cfg(feature = "Win32_Foundation")]
2080 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_PB_ARRAY {}
2081 #[cfg(feature = "Win32_Foundation")]
2082 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_PB_ARRAY {
2083     type Abi = Self;
2084     type DefaultType = Self;
2085 }
2086 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2087 #[repr(C)]
2088 #[cfg(feature = "Win32_Foundation")]
2089 pub struct DHCP_CLIENT_INFO_V4 {
2090     pub ClientIpAddress: u32,
2091     pub SubnetMask: u32,
2092     pub ClientHardwareAddress: DHCP_BINARY_DATA,
2093     pub ClientName: super::super::Foundation::PWSTR,
2094     pub ClientComment: super::super::Foundation::PWSTR,
2095     pub ClientLeaseExpires: DATE_TIME,
2096     pub OwnerHost: DHCP_HOST_INFO,
2097     pub bClientType: u8,
2098 }
2099 #[cfg(feature = "Win32_Foundation")]
2100 impl DHCP_CLIENT_INFO_V4 {}
2101 #[cfg(feature = "Win32_Foundation")]
2102 impl ::std::default::Default for DHCP_CLIENT_INFO_V4 {
default() -> Self2103     fn default() -> Self {
2104         unsafe { ::std::mem::zeroed() }
2105     }
2106 }
2107 #[cfg(feature = "Win32_Foundation")]
2108 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2109     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2110         fmt.debug_struct("DHCP_CLIENT_INFO_V4")
2111             .field("ClientIpAddress", &self.ClientIpAddress)
2112             .field("SubnetMask", &self.SubnetMask)
2113             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2114             .field("ClientName", &self.ClientName)
2115             .field("ClientComment", &self.ClientComment)
2116             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2117             .field("OwnerHost", &self.OwnerHost)
2118             .field("bClientType", &self.bClientType)
2119             .finish()
2120     }
2121 }
2122 #[cfg(feature = "Win32_Foundation")]
2123 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V4 {
eq(&self, other: &Self) -> bool2124     fn eq(&self, other: &Self) -> bool {
2125         self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost && self.bClientType == other.bClientType
2126     }
2127 }
2128 #[cfg(feature = "Win32_Foundation")]
2129 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V4 {}
2130 #[cfg(feature = "Win32_Foundation")]
2131 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V4 {
2132     type Abi = Self;
2133     type DefaultType = Self;
2134 }
2135 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2136 #[repr(C)]
2137 #[cfg(feature = "Win32_Foundation")]
2138 pub struct DHCP_CLIENT_INFO_V5 {
2139     pub ClientIpAddress: u32,
2140     pub SubnetMask: u32,
2141     pub ClientHardwareAddress: DHCP_BINARY_DATA,
2142     pub ClientName: super::super::Foundation::PWSTR,
2143     pub ClientComment: super::super::Foundation::PWSTR,
2144     pub ClientLeaseExpires: DATE_TIME,
2145     pub OwnerHost: DHCP_HOST_INFO,
2146     pub bClientType: u8,
2147     pub AddressState: u8,
2148 }
2149 #[cfg(feature = "Win32_Foundation")]
2150 impl DHCP_CLIENT_INFO_V5 {}
2151 #[cfg(feature = "Win32_Foundation")]
2152 impl ::std::default::Default for DHCP_CLIENT_INFO_V5 {
default() -> Self2153     fn default() -> Self {
2154         unsafe { ::std::mem::zeroed() }
2155     }
2156 }
2157 #[cfg(feature = "Win32_Foundation")]
2158 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2159     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2160         fmt.debug_struct("DHCP_CLIENT_INFO_V5")
2161             .field("ClientIpAddress", &self.ClientIpAddress)
2162             .field("SubnetMask", &self.SubnetMask)
2163             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2164             .field("ClientName", &self.ClientName)
2165             .field("ClientComment", &self.ClientComment)
2166             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2167             .field("OwnerHost", &self.OwnerHost)
2168             .field("bClientType", &self.bClientType)
2169             .field("AddressState", &self.AddressState)
2170             .finish()
2171     }
2172 }
2173 #[cfg(feature = "Win32_Foundation")]
2174 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V5 {
eq(&self, other: &Self) -> bool2175     fn eq(&self, other: &Self) -> bool {
2176         self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost && self.bClientType == other.bClientType && self.AddressState == other.AddressState
2177     }
2178 }
2179 #[cfg(feature = "Win32_Foundation")]
2180 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V5 {}
2181 #[cfg(feature = "Win32_Foundation")]
2182 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V5 {
2183     type Abi = Self;
2184     type DefaultType = Self;
2185 }
2186 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2187 #[repr(C)]
2188 #[cfg(feature = "Win32_Foundation")]
2189 pub struct DHCP_CLIENT_INFO_V6 {
2190     pub ClientIpAddress: DHCP_IPV6_ADDRESS,
2191     pub ClientDUID: DHCP_BINARY_DATA,
2192     pub AddressType: u32,
2193     pub IAID: u32,
2194     pub ClientName: super::super::Foundation::PWSTR,
2195     pub ClientComment: super::super::Foundation::PWSTR,
2196     pub ClientValidLeaseExpires: DATE_TIME,
2197     pub ClientPrefLeaseExpires: DATE_TIME,
2198     pub OwnerHost: DHCP_HOST_INFO_V6,
2199 }
2200 #[cfg(feature = "Win32_Foundation")]
2201 impl DHCP_CLIENT_INFO_V6 {}
2202 #[cfg(feature = "Win32_Foundation")]
2203 impl ::std::default::Default for DHCP_CLIENT_INFO_V6 {
default() -> Self2204     fn default() -> Self {
2205         unsafe { ::std::mem::zeroed() }
2206     }
2207 }
2208 #[cfg(feature = "Win32_Foundation")]
2209 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2210     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2211         fmt.debug_struct("DHCP_CLIENT_INFO_V6")
2212             .field("ClientIpAddress", &self.ClientIpAddress)
2213             .field("ClientDUID", &self.ClientDUID)
2214             .field("AddressType", &self.AddressType)
2215             .field("IAID", &self.IAID)
2216             .field("ClientName", &self.ClientName)
2217             .field("ClientComment", &self.ClientComment)
2218             .field("ClientValidLeaseExpires", &self.ClientValidLeaseExpires)
2219             .field("ClientPrefLeaseExpires", &self.ClientPrefLeaseExpires)
2220             .field("OwnerHost", &self.OwnerHost)
2221             .finish()
2222     }
2223 }
2224 #[cfg(feature = "Win32_Foundation")]
2225 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V6 {
eq(&self, other: &Self) -> bool2226     fn eq(&self, other: &Self) -> bool {
2227         self.ClientIpAddress == other.ClientIpAddress && self.ClientDUID == other.ClientDUID && self.AddressType == other.AddressType && self.IAID == other.IAID && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientValidLeaseExpires == other.ClientValidLeaseExpires && self.ClientPrefLeaseExpires == other.ClientPrefLeaseExpires && self.OwnerHost == other.OwnerHost
2228     }
2229 }
2230 #[cfg(feature = "Win32_Foundation")]
2231 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V6 {}
2232 #[cfg(feature = "Win32_Foundation")]
2233 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V6 {
2234     type Abi = Self;
2235     type DefaultType = Self;
2236 }
2237 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2238 #[repr(C)]
2239 #[cfg(feature = "Win32_Foundation")]
2240 pub struct DHCP_CLIENT_INFO_VQ {
2241     pub ClientIpAddress: u32,
2242     pub SubnetMask: u32,
2243     pub ClientHardwareAddress: DHCP_BINARY_DATA,
2244     pub ClientName: super::super::Foundation::PWSTR,
2245     pub ClientComment: super::super::Foundation::PWSTR,
2246     pub ClientLeaseExpires: DATE_TIME,
2247     pub OwnerHost: DHCP_HOST_INFO,
2248     pub bClientType: u8,
2249     pub AddressState: u8,
2250     pub Status: QuarantineStatus,
2251     pub ProbationEnds: DATE_TIME,
2252     pub QuarantineCapable: super::super::Foundation::BOOL,
2253 }
2254 #[cfg(feature = "Win32_Foundation")]
2255 impl DHCP_CLIENT_INFO_VQ {}
2256 #[cfg(feature = "Win32_Foundation")]
2257 impl ::std::default::Default for DHCP_CLIENT_INFO_VQ {
default() -> Self2258     fn default() -> Self {
2259         unsafe { ::std::mem::zeroed() }
2260     }
2261 }
2262 #[cfg(feature = "Win32_Foundation")]
2263 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2264     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2265         fmt.debug_struct("DHCP_CLIENT_INFO_VQ")
2266             .field("ClientIpAddress", &self.ClientIpAddress)
2267             .field("SubnetMask", &self.SubnetMask)
2268             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2269             .field("ClientName", &self.ClientName)
2270             .field("ClientComment", &self.ClientComment)
2271             .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2272             .field("OwnerHost", &self.OwnerHost)
2273             .field("bClientType", &self.bClientType)
2274             .field("AddressState", &self.AddressState)
2275             .field("Status", &self.Status)
2276             .field("ProbationEnds", &self.ProbationEnds)
2277             .field("QuarantineCapable", &self.QuarantineCapable)
2278             .finish()
2279     }
2280 }
2281 #[cfg(feature = "Win32_Foundation")]
2282 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_VQ {
eq(&self, other: &Self) -> bool2283     fn eq(&self, other: &Self) -> bool {
2284         self.ClientIpAddress == other.ClientIpAddress
2285             && self.SubnetMask == other.SubnetMask
2286             && self.ClientHardwareAddress == other.ClientHardwareAddress
2287             && self.ClientName == other.ClientName
2288             && self.ClientComment == other.ClientComment
2289             && self.ClientLeaseExpires == other.ClientLeaseExpires
2290             && self.OwnerHost == other.OwnerHost
2291             && self.bClientType == other.bClientType
2292             && self.AddressState == other.AddressState
2293             && self.Status == other.Status
2294             && self.ProbationEnds == other.ProbationEnds
2295             && self.QuarantineCapable == other.QuarantineCapable
2296     }
2297 }
2298 #[cfg(feature = "Win32_Foundation")]
2299 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_VQ {}
2300 #[cfg(feature = "Win32_Foundation")]
2301 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_VQ {
2302     type Abi = Self;
2303     type DefaultType = Self;
2304 }
2305 #[repr(C)]
2306 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
2307 pub struct DHCP_CLIENT_SEARCH_UNION(pub u8);
2308 pub const DHCP_CONTROL_CONTINUE: u32 = 4u32;
2309 pub const DHCP_CONTROL_PAUSE: u32 = 3u32;
2310 pub const DHCP_CONTROL_START: u32 = 1u32;
2311 pub const DHCP_CONTROL_STOP: u32 = 2u32;
2312 pub const DHCP_DROP_DUPLICATE: u32 = 1u32;
2313 pub const DHCP_DROP_GEN_FAILURE: u32 = 256u32;
2314 pub const DHCP_DROP_INTERNAL_ERROR: u32 = 3u32;
2315 pub const DHCP_DROP_INVALID: u32 = 8u32;
2316 pub const DHCP_DROP_NOADDRESS: u32 = 10u32;
2317 pub const DHCP_DROP_NOMEM: u32 = 2u32;
2318 pub const DHCP_DROP_NO_SUBNETS: u32 = 7u32;
2319 pub const DHCP_DROP_PAUSED: u32 = 6u32;
2320 pub const DHCP_DROP_PROCESSED: u32 = 11u32;
2321 pub const DHCP_DROP_TIMEOUT: u32 = 4u32;
2322 pub const DHCP_DROP_UNAUTH: u32 = 5u32;
2323 pub const DHCP_DROP_WRONG_SERVER: u32 = 9u32;
2324 pub const DHCP_ENDPOINT_FLAG_CANT_MODIFY: u32 = 1u32;
2325 pub const DHCP_FAILOVER_DELETE_SCOPES: u32 = 1u32;
2326 pub const DHCP_FAILOVER_MAX_NUM_ADD_SCOPES: u32 = 400u32;
2327 pub const DHCP_FAILOVER_MAX_NUM_REL: u32 = 31u32;
2328 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2329 #[repr(transparent)]
2330 pub struct DHCP_FAILOVER_MODE(pub i32);
2331 pub const LoadBalance: DHCP_FAILOVER_MODE = DHCP_FAILOVER_MODE(0i32);
2332 pub const HotStandby: DHCP_FAILOVER_MODE = DHCP_FAILOVER_MODE(1i32);
2333 impl ::std::convert::From<i32> for DHCP_FAILOVER_MODE {
from(value: i32) -> Self2334     fn from(value: i32) -> Self {
2335         Self(value)
2336     }
2337 }
2338 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_MODE {
2339     type Abi = Self;
2340     type DefaultType = Self;
2341 }
2342 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2343 #[repr(C)]
2344 #[cfg(feature = "Win32_Foundation")]
2345 pub struct DHCP_FAILOVER_RELATIONSHIP {
2346     pub PrimaryServer: u32,
2347     pub SecondaryServer: u32,
2348     pub Mode: DHCP_FAILOVER_MODE,
2349     pub ServerType: DHCP_FAILOVER_SERVER,
2350     pub State: FSM_STATE,
2351     pub PrevState: FSM_STATE,
2352     pub Mclt: u32,
2353     pub SafePeriod: u32,
2354     pub RelationshipName: super::super::Foundation::PWSTR,
2355     pub PrimaryServerName: super::super::Foundation::PWSTR,
2356     pub SecondaryServerName: super::super::Foundation::PWSTR,
2357     pub pScopes: *mut DHCP_IP_ARRAY,
2358     pub Percentage: u8,
2359     pub SharedSecret: super::super::Foundation::PWSTR,
2360 }
2361 #[cfg(feature = "Win32_Foundation")]
2362 impl DHCP_FAILOVER_RELATIONSHIP {}
2363 #[cfg(feature = "Win32_Foundation")]
2364 impl ::std::default::Default for DHCP_FAILOVER_RELATIONSHIP {
default() -> Self2365     fn default() -> Self {
2366         unsafe { ::std::mem::zeroed() }
2367     }
2368 }
2369 #[cfg(feature = "Win32_Foundation")]
2370 impl ::std::fmt::Debug for DHCP_FAILOVER_RELATIONSHIP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2371     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2372         fmt.debug_struct("DHCP_FAILOVER_RELATIONSHIP")
2373             .field("PrimaryServer", &self.PrimaryServer)
2374             .field("SecondaryServer", &self.SecondaryServer)
2375             .field("Mode", &self.Mode)
2376             .field("ServerType", &self.ServerType)
2377             .field("State", &self.State)
2378             .field("PrevState", &self.PrevState)
2379             .field("Mclt", &self.Mclt)
2380             .field("SafePeriod", &self.SafePeriod)
2381             .field("RelationshipName", &self.RelationshipName)
2382             .field("PrimaryServerName", &self.PrimaryServerName)
2383             .field("SecondaryServerName", &self.SecondaryServerName)
2384             .field("pScopes", &self.pScopes)
2385             .field("Percentage", &self.Percentage)
2386             .field("SharedSecret", &self.SharedSecret)
2387             .finish()
2388     }
2389 }
2390 #[cfg(feature = "Win32_Foundation")]
2391 impl ::std::cmp::PartialEq for DHCP_FAILOVER_RELATIONSHIP {
eq(&self, other: &Self) -> bool2392     fn eq(&self, other: &Self) -> bool {
2393         self.PrimaryServer == other.PrimaryServer
2394             && self.SecondaryServer == other.SecondaryServer
2395             && self.Mode == other.Mode
2396             && self.ServerType == other.ServerType
2397             && self.State == other.State
2398             && self.PrevState == other.PrevState
2399             && self.Mclt == other.Mclt
2400             && self.SafePeriod == other.SafePeriod
2401             && self.RelationshipName == other.RelationshipName
2402             && self.PrimaryServerName == other.PrimaryServerName
2403             && self.SecondaryServerName == other.SecondaryServerName
2404             && self.pScopes == other.pScopes
2405             && self.Percentage == other.Percentage
2406             && self.SharedSecret == other.SharedSecret
2407     }
2408 }
2409 #[cfg(feature = "Win32_Foundation")]
2410 impl ::std::cmp::Eq for DHCP_FAILOVER_RELATIONSHIP {}
2411 #[cfg(feature = "Win32_Foundation")]
2412 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_RELATIONSHIP {
2413     type Abi = Self;
2414     type DefaultType = Self;
2415 }
2416 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2417 #[repr(C)]
2418 #[cfg(feature = "Win32_Foundation")]
2419 pub struct DHCP_FAILOVER_RELATIONSHIP_ARRAY {
2420     pub NumElements: u32,
2421     pub pRelationships: *mut DHCP_FAILOVER_RELATIONSHIP,
2422 }
2423 #[cfg(feature = "Win32_Foundation")]
2424 impl DHCP_FAILOVER_RELATIONSHIP_ARRAY {}
2425 #[cfg(feature = "Win32_Foundation")]
2426 impl ::std::default::Default for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
default() -> Self2427     fn default() -> Self {
2428         unsafe { ::std::mem::zeroed() }
2429     }
2430 }
2431 #[cfg(feature = "Win32_Foundation")]
2432 impl ::std::fmt::Debug for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2433     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2434         fmt.debug_struct("DHCP_FAILOVER_RELATIONSHIP_ARRAY").field("NumElements", &self.NumElements).field("pRelationships", &self.pRelationships).finish()
2435     }
2436 }
2437 #[cfg(feature = "Win32_Foundation")]
2438 impl ::std::cmp::PartialEq for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
eq(&self, other: &Self) -> bool2439     fn eq(&self, other: &Self) -> bool {
2440         self.NumElements == other.NumElements && self.pRelationships == other.pRelationships
2441     }
2442 }
2443 #[cfg(feature = "Win32_Foundation")]
2444 impl ::std::cmp::Eq for DHCP_FAILOVER_RELATIONSHIP_ARRAY {}
2445 #[cfg(feature = "Win32_Foundation")]
2446 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
2447     type Abi = Self;
2448     type DefaultType = Self;
2449 }
2450 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2451 #[repr(transparent)]
2452 pub struct DHCP_FAILOVER_SERVER(pub i32);
2453 pub const PrimaryServer: DHCP_FAILOVER_SERVER = DHCP_FAILOVER_SERVER(0i32);
2454 pub const SecondaryServer: DHCP_FAILOVER_SERVER = DHCP_FAILOVER_SERVER(1i32);
2455 impl ::std::convert::From<i32> for DHCP_FAILOVER_SERVER {
from(value: i32) -> Self2456     fn from(value: i32) -> Self {
2457         Self(value)
2458     }
2459 }
2460 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_SERVER {
2461     type Abi = Self;
2462     type DefaultType = Self;
2463 }
2464 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2465 #[repr(C)]
2466 pub struct DHCP_FAILOVER_STATISTICS {
2467     pub NumAddr: u32,
2468     pub AddrFree: u32,
2469     pub AddrInUse: u32,
2470     pub PartnerAddrFree: u32,
2471     pub ThisAddrFree: u32,
2472     pub PartnerAddrInUse: u32,
2473     pub ThisAddrInUse: u32,
2474 }
2475 impl DHCP_FAILOVER_STATISTICS {}
2476 impl ::std::default::Default for DHCP_FAILOVER_STATISTICS {
default() -> Self2477     fn default() -> Self {
2478         unsafe { ::std::mem::zeroed() }
2479     }
2480 }
2481 impl ::std::fmt::Debug for DHCP_FAILOVER_STATISTICS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2482     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2483         fmt.debug_struct("DHCP_FAILOVER_STATISTICS")
2484             .field("NumAddr", &self.NumAddr)
2485             .field("AddrFree", &self.AddrFree)
2486             .field("AddrInUse", &self.AddrInUse)
2487             .field("PartnerAddrFree", &self.PartnerAddrFree)
2488             .field("ThisAddrFree", &self.ThisAddrFree)
2489             .field("PartnerAddrInUse", &self.PartnerAddrInUse)
2490             .field("ThisAddrInUse", &self.ThisAddrInUse)
2491             .finish()
2492     }
2493 }
2494 impl ::std::cmp::PartialEq for DHCP_FAILOVER_STATISTICS {
eq(&self, other: &Self) -> bool2495     fn eq(&self, other: &Self) -> bool {
2496         self.NumAddr == other.NumAddr && self.AddrFree == other.AddrFree && self.AddrInUse == other.AddrInUse && self.PartnerAddrFree == other.PartnerAddrFree && self.ThisAddrFree == other.ThisAddrFree && self.PartnerAddrInUse == other.PartnerAddrInUse && self.ThisAddrInUse == other.ThisAddrInUse
2497     }
2498 }
2499 impl ::std::cmp::Eq for DHCP_FAILOVER_STATISTICS {}
2500 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_STATISTICS {
2501     type Abi = Self;
2502     type DefaultType = Self;
2503 }
2504 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2505 #[repr(C)]
2506 #[cfg(feature = "Win32_Foundation")]
2507 pub struct DHCP_FILTER_ADD_INFO {
2508     pub AddrPatt: DHCP_ADDR_PATTERN,
2509     pub Comment: super::super::Foundation::PWSTR,
2510     pub ListType: DHCP_FILTER_LIST_TYPE,
2511 }
2512 #[cfg(feature = "Win32_Foundation")]
2513 impl DHCP_FILTER_ADD_INFO {}
2514 #[cfg(feature = "Win32_Foundation")]
2515 impl ::std::default::Default for DHCP_FILTER_ADD_INFO {
default() -> Self2516     fn default() -> Self {
2517         unsafe { ::std::mem::zeroed() }
2518     }
2519 }
2520 #[cfg(feature = "Win32_Foundation")]
2521 impl ::std::fmt::Debug for DHCP_FILTER_ADD_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2522     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2523         fmt.debug_struct("DHCP_FILTER_ADD_INFO").field("AddrPatt", &self.AddrPatt).field("Comment", &self.Comment).field("ListType", &self.ListType).finish()
2524     }
2525 }
2526 #[cfg(feature = "Win32_Foundation")]
2527 impl ::std::cmp::PartialEq for DHCP_FILTER_ADD_INFO {
eq(&self, other: &Self) -> bool2528     fn eq(&self, other: &Self) -> bool {
2529         self.AddrPatt == other.AddrPatt && self.Comment == other.Comment && self.ListType == other.ListType
2530     }
2531 }
2532 #[cfg(feature = "Win32_Foundation")]
2533 impl ::std::cmp::Eq for DHCP_FILTER_ADD_INFO {}
2534 #[cfg(feature = "Win32_Foundation")]
2535 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_ADD_INFO {
2536     type Abi = Self;
2537     type DefaultType = Self;
2538 }
2539 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2540 #[repr(C)]
2541 #[cfg(feature = "Win32_Foundation")]
2542 pub struct DHCP_FILTER_ENUM_INFO {
2543     pub NumElements: u32,
2544     pub pEnumRecords: *mut DHCP_FILTER_RECORD,
2545 }
2546 #[cfg(feature = "Win32_Foundation")]
2547 impl DHCP_FILTER_ENUM_INFO {}
2548 #[cfg(feature = "Win32_Foundation")]
2549 impl ::std::default::Default for DHCP_FILTER_ENUM_INFO {
default() -> Self2550     fn default() -> Self {
2551         unsafe { ::std::mem::zeroed() }
2552     }
2553 }
2554 #[cfg(feature = "Win32_Foundation")]
2555 impl ::std::fmt::Debug for DHCP_FILTER_ENUM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2556     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2557         fmt.debug_struct("DHCP_FILTER_ENUM_INFO").field("NumElements", &self.NumElements).field("pEnumRecords", &self.pEnumRecords).finish()
2558     }
2559 }
2560 #[cfg(feature = "Win32_Foundation")]
2561 impl ::std::cmp::PartialEq for DHCP_FILTER_ENUM_INFO {
eq(&self, other: &Self) -> bool2562     fn eq(&self, other: &Self) -> bool {
2563         self.NumElements == other.NumElements && self.pEnumRecords == other.pEnumRecords
2564     }
2565 }
2566 #[cfg(feature = "Win32_Foundation")]
2567 impl ::std::cmp::Eq for DHCP_FILTER_ENUM_INFO {}
2568 #[cfg(feature = "Win32_Foundation")]
2569 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_ENUM_INFO {
2570     type Abi = Self;
2571     type DefaultType = Self;
2572 }
2573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2574 #[repr(C)]
2575 #[cfg(feature = "Win32_Foundation")]
2576 pub struct DHCP_FILTER_GLOBAL_INFO {
2577     pub EnforceAllowList: super::super::Foundation::BOOL,
2578     pub EnforceDenyList: super::super::Foundation::BOOL,
2579 }
2580 #[cfg(feature = "Win32_Foundation")]
2581 impl DHCP_FILTER_GLOBAL_INFO {}
2582 #[cfg(feature = "Win32_Foundation")]
2583 impl ::std::default::Default for DHCP_FILTER_GLOBAL_INFO {
default() -> Self2584     fn default() -> Self {
2585         unsafe { ::std::mem::zeroed() }
2586     }
2587 }
2588 #[cfg(feature = "Win32_Foundation")]
2589 impl ::std::fmt::Debug for DHCP_FILTER_GLOBAL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2590     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2591         fmt.debug_struct("DHCP_FILTER_GLOBAL_INFO").field("EnforceAllowList", &self.EnforceAllowList).field("EnforceDenyList", &self.EnforceDenyList).finish()
2592     }
2593 }
2594 #[cfg(feature = "Win32_Foundation")]
2595 impl ::std::cmp::PartialEq for DHCP_FILTER_GLOBAL_INFO {
eq(&self, other: &Self) -> bool2596     fn eq(&self, other: &Self) -> bool {
2597         self.EnforceAllowList == other.EnforceAllowList && self.EnforceDenyList == other.EnforceDenyList
2598     }
2599 }
2600 #[cfg(feature = "Win32_Foundation")]
2601 impl ::std::cmp::Eq for DHCP_FILTER_GLOBAL_INFO {}
2602 #[cfg(feature = "Win32_Foundation")]
2603 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_GLOBAL_INFO {
2604     type Abi = Self;
2605     type DefaultType = Self;
2606 }
2607 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2608 #[repr(transparent)]
2609 pub struct DHCP_FILTER_LIST_TYPE(pub i32);
2610 pub const Deny: DHCP_FILTER_LIST_TYPE = DHCP_FILTER_LIST_TYPE(0i32);
2611 pub const Allow: DHCP_FILTER_LIST_TYPE = DHCP_FILTER_LIST_TYPE(1i32);
2612 impl ::std::convert::From<i32> for DHCP_FILTER_LIST_TYPE {
from(value: i32) -> Self2613     fn from(value: i32) -> Self {
2614         Self(value)
2615     }
2616 }
2617 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_LIST_TYPE {
2618     type Abi = Self;
2619     type DefaultType = Self;
2620 }
2621 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2622 #[repr(C)]
2623 #[cfg(feature = "Win32_Foundation")]
2624 pub struct DHCP_FILTER_RECORD {
2625     pub AddrPatt: DHCP_ADDR_PATTERN,
2626     pub Comment: super::super::Foundation::PWSTR,
2627 }
2628 #[cfg(feature = "Win32_Foundation")]
2629 impl DHCP_FILTER_RECORD {}
2630 #[cfg(feature = "Win32_Foundation")]
2631 impl ::std::default::Default for DHCP_FILTER_RECORD {
default() -> Self2632     fn default() -> Self {
2633         unsafe { ::std::mem::zeroed() }
2634     }
2635 }
2636 #[cfg(feature = "Win32_Foundation")]
2637 impl ::std::fmt::Debug for DHCP_FILTER_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2638     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2639         fmt.debug_struct("DHCP_FILTER_RECORD").field("AddrPatt", &self.AddrPatt).field("Comment", &self.Comment).finish()
2640     }
2641 }
2642 #[cfg(feature = "Win32_Foundation")]
2643 impl ::std::cmp::PartialEq for DHCP_FILTER_RECORD {
eq(&self, other: &Self) -> bool2644     fn eq(&self, other: &Self) -> bool {
2645         self.AddrPatt == other.AddrPatt && self.Comment == other.Comment
2646     }
2647 }
2648 #[cfg(feature = "Win32_Foundation")]
2649 impl ::std::cmp::Eq for DHCP_FILTER_RECORD {}
2650 #[cfg(feature = "Win32_Foundation")]
2651 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_RECORD {
2652     type Abi = Self;
2653     type DefaultType = Self;
2654 }
2655 pub const DHCP_FLAGS_DONT_ACCESS_DS: u32 = 1u32;
2656 pub const DHCP_FLAGS_DONT_DO_RPC: u32 = 2u32;
2657 pub const DHCP_FLAGS_OPTION_IS_VENDOR: u32 = 3u32;
2658 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2659 #[repr(transparent)]
2660 pub struct DHCP_FORCE_FLAG(pub i32);
2661 pub const DhcpFullForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(0i32);
2662 pub const DhcpNoForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(1i32);
2663 pub const DhcpFailoverForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(2i32);
2664 impl ::std::convert::From<i32> for DHCP_FORCE_FLAG {
from(value: i32) -> Self2665     fn from(value: i32) -> Self {
2666         Self(value)
2667     }
2668 }
2669 unsafe impl ::windows::runtime::Abi for DHCP_FORCE_FLAG {
2670     type Abi = Self;
2671     type DefaultType = Self;
2672 }
2673 pub const DHCP_GIVE_ADDRESS_NEW: u32 = 805306369u32;
2674 pub const DHCP_GIVE_ADDRESS_OLD: u32 = 805306370u32;
2675 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2676 #[repr(C)]
2677 #[cfg(feature = "Win32_Foundation")]
2678 pub struct DHCP_HOST_INFO {
2679     pub IpAddress: u32,
2680     pub NetBiosName: super::super::Foundation::PWSTR,
2681     pub HostName: super::super::Foundation::PWSTR,
2682 }
2683 #[cfg(feature = "Win32_Foundation")]
2684 impl DHCP_HOST_INFO {}
2685 #[cfg(feature = "Win32_Foundation")]
2686 impl ::std::default::Default for DHCP_HOST_INFO {
default() -> Self2687     fn default() -> Self {
2688         unsafe { ::std::mem::zeroed() }
2689     }
2690 }
2691 #[cfg(feature = "Win32_Foundation")]
2692 impl ::std::fmt::Debug for DHCP_HOST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2693     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2694         fmt.debug_struct("DHCP_HOST_INFO").field("IpAddress", &self.IpAddress).field("NetBiosName", &self.NetBiosName).field("HostName", &self.HostName).finish()
2695     }
2696 }
2697 #[cfg(feature = "Win32_Foundation")]
2698 impl ::std::cmp::PartialEq for DHCP_HOST_INFO {
eq(&self, other: &Self) -> bool2699     fn eq(&self, other: &Self) -> bool {
2700         self.IpAddress == other.IpAddress && self.NetBiosName == other.NetBiosName && self.HostName == other.HostName
2701     }
2702 }
2703 #[cfg(feature = "Win32_Foundation")]
2704 impl ::std::cmp::Eq for DHCP_HOST_INFO {}
2705 #[cfg(feature = "Win32_Foundation")]
2706 unsafe impl ::windows::runtime::Abi for DHCP_HOST_INFO {
2707     type Abi = Self;
2708     type DefaultType = Self;
2709 }
2710 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2711 #[repr(C)]
2712 #[cfg(feature = "Win32_Foundation")]
2713 pub struct DHCP_HOST_INFO_V6 {
2714     pub IpAddress: DHCP_IPV6_ADDRESS,
2715     pub NetBiosName: super::super::Foundation::PWSTR,
2716     pub HostName: super::super::Foundation::PWSTR,
2717 }
2718 #[cfg(feature = "Win32_Foundation")]
2719 impl DHCP_HOST_INFO_V6 {}
2720 #[cfg(feature = "Win32_Foundation")]
2721 impl ::std::default::Default for DHCP_HOST_INFO_V6 {
default() -> Self2722     fn default() -> Self {
2723         unsafe { ::std::mem::zeroed() }
2724     }
2725 }
2726 #[cfg(feature = "Win32_Foundation")]
2727 impl ::std::fmt::Debug for DHCP_HOST_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2728     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2729         fmt.debug_struct("DHCP_HOST_INFO_V6").field("IpAddress", &self.IpAddress).field("NetBiosName", &self.NetBiosName).field("HostName", &self.HostName).finish()
2730     }
2731 }
2732 #[cfg(feature = "Win32_Foundation")]
2733 impl ::std::cmp::PartialEq for DHCP_HOST_INFO_V6 {
eq(&self, other: &Self) -> bool2734     fn eq(&self, other: &Self) -> bool {
2735         self.IpAddress == other.IpAddress && self.NetBiosName == other.NetBiosName && self.HostName == other.HostName
2736     }
2737 }
2738 #[cfg(feature = "Win32_Foundation")]
2739 impl ::std::cmp::Eq for DHCP_HOST_INFO_V6 {}
2740 #[cfg(feature = "Win32_Foundation")]
2741 unsafe impl ::windows::runtime::Abi for DHCP_HOST_INFO_V6 {
2742     type Abi = Self;
2743     type DefaultType = Self;
2744 }
2745 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2746 #[repr(C)]
2747 pub struct DHCP_IPV6_ADDRESS {
2748     pub HighOrderBits: u64,
2749     pub LowOrderBits: u64,
2750 }
2751 impl DHCP_IPV6_ADDRESS {}
2752 impl ::std::default::Default for DHCP_IPV6_ADDRESS {
default() -> Self2753     fn default() -> Self {
2754         unsafe { ::std::mem::zeroed() }
2755     }
2756 }
2757 impl ::std::fmt::Debug for DHCP_IPV6_ADDRESS {
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("DHCP_IPV6_ADDRESS").field("HighOrderBits", &self.HighOrderBits).field("LowOrderBits", &self.LowOrderBits).finish()
2760     }
2761 }
2762 impl ::std::cmp::PartialEq for DHCP_IPV6_ADDRESS {
eq(&self, other: &Self) -> bool2763     fn eq(&self, other: &Self) -> bool {
2764         self.HighOrderBits == other.HighOrderBits && self.LowOrderBits == other.LowOrderBits
2765     }
2766 }
2767 impl ::std::cmp::Eq for DHCP_IPV6_ADDRESS {}
2768 unsafe impl ::windows::runtime::Abi for DHCP_IPV6_ADDRESS {
2769     type Abi = Self;
2770     type DefaultType = Self;
2771 }
2772 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2773 #[repr(C)]
2774 pub struct DHCP_IP_ARRAY {
2775     pub NumElements: u32,
2776     pub Elements: *mut u32,
2777 }
2778 impl DHCP_IP_ARRAY {}
2779 impl ::std::default::Default for DHCP_IP_ARRAY {
default() -> Self2780     fn default() -> Self {
2781         unsafe { ::std::mem::zeroed() }
2782     }
2783 }
2784 impl ::std::fmt::Debug for DHCP_IP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2785     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2786         fmt.debug_struct("DHCP_IP_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
2787     }
2788 }
2789 impl ::std::cmp::PartialEq for DHCP_IP_ARRAY {
eq(&self, other: &Self) -> bool2790     fn eq(&self, other: &Self) -> bool {
2791         self.NumElements == other.NumElements && self.Elements == other.Elements
2792     }
2793 }
2794 impl ::std::cmp::Eq for DHCP_IP_ARRAY {}
2795 unsafe impl ::windows::runtime::Abi for DHCP_IP_ARRAY {
2796     type Abi = Self;
2797     type DefaultType = Self;
2798 }
2799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2800 #[repr(C)]
2801 pub struct DHCP_IP_CLUSTER {
2802     pub ClusterAddress: u32,
2803     pub ClusterMask: u32,
2804 }
2805 impl DHCP_IP_CLUSTER {}
2806 impl ::std::default::Default for DHCP_IP_CLUSTER {
default() -> Self2807     fn default() -> Self {
2808         unsafe { ::std::mem::zeroed() }
2809     }
2810 }
2811 impl ::std::fmt::Debug for DHCP_IP_CLUSTER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2812     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2813         fmt.debug_struct("DHCP_IP_CLUSTER").field("ClusterAddress", &self.ClusterAddress).field("ClusterMask", &self.ClusterMask).finish()
2814     }
2815 }
2816 impl ::std::cmp::PartialEq for DHCP_IP_CLUSTER {
eq(&self, other: &Self) -> bool2817     fn eq(&self, other: &Self) -> bool {
2818         self.ClusterAddress == other.ClusterAddress && self.ClusterMask == other.ClusterMask
2819     }
2820 }
2821 impl ::std::cmp::Eq for DHCP_IP_CLUSTER {}
2822 unsafe impl ::windows::runtime::Abi for DHCP_IP_CLUSTER {
2823     type Abi = Self;
2824     type DefaultType = Self;
2825 }
2826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2827 #[repr(C)]
2828 pub struct DHCP_IP_RANGE {
2829     pub StartAddress: u32,
2830     pub EndAddress: u32,
2831 }
2832 impl DHCP_IP_RANGE {}
2833 impl ::std::default::Default for DHCP_IP_RANGE {
default() -> Self2834     fn default() -> Self {
2835         unsafe { ::std::mem::zeroed() }
2836     }
2837 }
2838 impl ::std::fmt::Debug for DHCP_IP_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2839     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2840         fmt.debug_struct("DHCP_IP_RANGE").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).finish()
2841     }
2842 }
2843 impl ::std::cmp::PartialEq for DHCP_IP_RANGE {
eq(&self, other: &Self) -> bool2844     fn eq(&self, other: &Self) -> bool {
2845         self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress
2846     }
2847 }
2848 impl ::std::cmp::Eq for DHCP_IP_RANGE {}
2849 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE {
2850     type Abi = Self;
2851     type DefaultType = Self;
2852 }
2853 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2854 #[repr(C)]
2855 pub struct DHCP_IP_RANGE_ARRAY {
2856     pub NumElements: u32,
2857     pub Elements: *mut DHCP_IP_RANGE,
2858 }
2859 impl DHCP_IP_RANGE_ARRAY {}
2860 impl ::std::default::Default for DHCP_IP_RANGE_ARRAY {
default() -> Self2861     fn default() -> Self {
2862         unsafe { ::std::mem::zeroed() }
2863     }
2864 }
2865 impl ::std::fmt::Debug for DHCP_IP_RANGE_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2866     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2867         fmt.debug_struct("DHCP_IP_RANGE_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
2868     }
2869 }
2870 impl ::std::cmp::PartialEq for DHCP_IP_RANGE_ARRAY {
eq(&self, other: &Self) -> bool2871     fn eq(&self, other: &Self) -> bool {
2872         self.NumElements == other.NumElements && self.Elements == other.Elements
2873     }
2874 }
2875 impl ::std::cmp::Eq for DHCP_IP_RANGE_ARRAY {}
2876 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE_ARRAY {
2877     type Abi = Self;
2878     type DefaultType = Self;
2879 }
2880 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2881 #[repr(C)]
2882 pub struct DHCP_IP_RANGE_V6 {
2883     pub StartAddress: DHCP_IPV6_ADDRESS,
2884     pub EndAddress: DHCP_IPV6_ADDRESS,
2885 }
2886 impl DHCP_IP_RANGE_V6 {}
2887 impl ::std::default::Default for DHCP_IP_RANGE_V6 {
default() -> Self2888     fn default() -> Self {
2889         unsafe { ::std::mem::zeroed() }
2890     }
2891 }
2892 impl ::std::fmt::Debug for DHCP_IP_RANGE_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2893     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2894         fmt.debug_struct("DHCP_IP_RANGE_V6").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).finish()
2895     }
2896 }
2897 impl ::std::cmp::PartialEq for DHCP_IP_RANGE_V6 {
eq(&self, other: &Self) -> bool2898     fn eq(&self, other: &Self) -> bool {
2899         self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress
2900     }
2901 }
2902 impl ::std::cmp::Eq for DHCP_IP_RANGE_V6 {}
2903 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE_V6 {
2904     type Abi = Self;
2905     type DefaultType = Self;
2906 }
2907 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2908 #[repr(C)]
2909 pub struct DHCP_IP_RESERVATION {
2910     pub ReservedIpAddress: u32,
2911     pub ReservedForClient: *mut DHCP_BINARY_DATA,
2912 }
2913 impl DHCP_IP_RESERVATION {}
2914 impl ::std::default::Default for DHCP_IP_RESERVATION {
default() -> Self2915     fn default() -> Self {
2916         unsafe { ::std::mem::zeroed() }
2917     }
2918 }
2919 impl ::std::fmt::Debug for DHCP_IP_RESERVATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2920     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2921         fmt.debug_struct("DHCP_IP_RESERVATION").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).finish()
2922     }
2923 }
2924 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION {
eq(&self, other: &Self) -> bool2925     fn eq(&self, other: &Self) -> bool {
2926         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient
2927     }
2928 }
2929 impl ::std::cmp::Eq for DHCP_IP_RESERVATION {}
2930 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION {
2931     type Abi = Self;
2932     type DefaultType = Self;
2933 }
2934 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2935 #[repr(C)]
2936 #[cfg(feature = "Win32_Foundation")]
2937 pub struct DHCP_IP_RESERVATION_INFO {
2938     pub ReservedIpAddress: u32,
2939     pub ReservedForClient: DHCP_BINARY_DATA,
2940     pub ReservedClientName: super::super::Foundation::PWSTR,
2941     pub ReservedClientDesc: super::super::Foundation::PWSTR,
2942     pub bAllowedClientTypes: u8,
2943     pub fOptionsPresent: u8,
2944 }
2945 #[cfg(feature = "Win32_Foundation")]
2946 impl DHCP_IP_RESERVATION_INFO {}
2947 #[cfg(feature = "Win32_Foundation")]
2948 impl ::std::default::Default for DHCP_IP_RESERVATION_INFO {
default() -> Self2949     fn default() -> Self {
2950         unsafe { ::std::mem::zeroed() }
2951     }
2952 }
2953 #[cfg(feature = "Win32_Foundation")]
2954 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2955     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2956         fmt.debug_struct("DHCP_IP_RESERVATION_INFO")
2957             .field("ReservedIpAddress", &self.ReservedIpAddress)
2958             .field("ReservedForClient", &self.ReservedForClient)
2959             .field("ReservedClientName", &self.ReservedClientName)
2960             .field("ReservedClientDesc", &self.ReservedClientDesc)
2961             .field("bAllowedClientTypes", &self.bAllowedClientTypes)
2962             .field("fOptionsPresent", &self.fOptionsPresent)
2963             .finish()
2964     }
2965 }
2966 #[cfg(feature = "Win32_Foundation")]
2967 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_INFO {
eq(&self, other: &Self) -> bool2968     fn eq(&self, other: &Self) -> bool {
2969         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.ReservedClientName == other.ReservedClientName && self.ReservedClientDesc == other.ReservedClientDesc && self.bAllowedClientTypes == other.bAllowedClientTypes && self.fOptionsPresent == other.fOptionsPresent
2970     }
2971 }
2972 #[cfg(feature = "Win32_Foundation")]
2973 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_INFO {}
2974 #[cfg(feature = "Win32_Foundation")]
2975 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_INFO {
2976     type Abi = Self;
2977     type DefaultType = Self;
2978 }
2979 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2980 #[repr(C)]
2981 pub struct DHCP_IP_RESERVATION_V4 {
2982     pub ReservedIpAddress: u32,
2983     pub ReservedForClient: *mut DHCP_BINARY_DATA,
2984     pub bAllowedClientTypes: u8,
2985 }
2986 impl DHCP_IP_RESERVATION_V4 {}
2987 impl ::std::default::Default for DHCP_IP_RESERVATION_V4 {
default() -> Self2988     fn default() -> Self {
2989         unsafe { ::std::mem::zeroed() }
2990     }
2991 }
2992 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2993     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2994         fmt.debug_struct("DHCP_IP_RESERVATION_V4").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).field("bAllowedClientTypes", &self.bAllowedClientTypes).finish()
2995     }
2996 }
2997 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_V4 {
eq(&self, other: &Self) -> bool2998     fn eq(&self, other: &Self) -> bool {
2999         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.bAllowedClientTypes == other.bAllowedClientTypes
3000     }
3001 }
3002 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_V4 {}
3003 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_V4 {
3004     type Abi = Self;
3005     type DefaultType = Self;
3006 }
3007 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3008 #[repr(C)]
3009 pub struct DHCP_IP_RESERVATION_V6 {
3010     pub ReservedIpAddress: DHCP_IPV6_ADDRESS,
3011     pub ReservedForClient: *mut DHCP_BINARY_DATA,
3012     pub InterfaceId: u32,
3013 }
3014 impl DHCP_IP_RESERVATION_V6 {}
3015 impl ::std::default::Default for DHCP_IP_RESERVATION_V6 {
default() -> Self3016     fn default() -> Self {
3017         unsafe { ::std::mem::zeroed() }
3018     }
3019 }
3020 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3021     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3022         fmt.debug_struct("DHCP_IP_RESERVATION_V6").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).field("InterfaceId", &self.InterfaceId).finish()
3023     }
3024 }
3025 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_V6 {
eq(&self, other: &Self) -> bool3026     fn eq(&self, other: &Self) -> bool {
3027         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.InterfaceId == other.InterfaceId
3028     }
3029 }
3030 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_V6 {}
3031 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_V6 {
3032     type Abi = Self;
3033     type DefaultType = Self;
3034 }
3035 pub const DHCP_MAX_DELAY: u32 = 1000u32;
3036 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3037 #[repr(C)]
3038 pub struct DHCP_MIB_INFO {
3039     pub Discovers: u32,
3040     pub Offers: u32,
3041     pub Requests: u32,
3042     pub Acks: u32,
3043     pub Naks: u32,
3044     pub Declines: u32,
3045     pub Releases: u32,
3046     pub ServerStartTime: DATE_TIME,
3047     pub Scopes: u32,
3048     pub ScopeInfo: *mut SCOPE_MIB_INFO,
3049 }
3050 impl DHCP_MIB_INFO {}
3051 impl ::std::default::Default for DHCP_MIB_INFO {
default() -> Self3052     fn default() -> Self {
3053         unsafe { ::std::mem::zeroed() }
3054     }
3055 }
3056 impl ::std::fmt::Debug for DHCP_MIB_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3057     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3058         fmt.debug_struct("DHCP_MIB_INFO")
3059             .field("Discovers", &self.Discovers)
3060             .field("Offers", &self.Offers)
3061             .field("Requests", &self.Requests)
3062             .field("Acks", &self.Acks)
3063             .field("Naks", &self.Naks)
3064             .field("Declines", &self.Declines)
3065             .field("Releases", &self.Releases)
3066             .field("ServerStartTime", &self.ServerStartTime)
3067             .field("Scopes", &self.Scopes)
3068             .field("ScopeInfo", &self.ScopeInfo)
3069             .finish()
3070     }
3071 }
3072 impl ::std::cmp::PartialEq for DHCP_MIB_INFO {
eq(&self, other: &Self) -> bool3073     fn eq(&self, other: &Self) -> bool {
3074         self.Discovers == other.Discovers && self.Offers == other.Offers && self.Requests == other.Requests && self.Acks == other.Acks && self.Naks == other.Naks && self.Declines == other.Declines && self.Releases == other.Releases && self.ServerStartTime == other.ServerStartTime && self.Scopes == other.Scopes && self.ScopeInfo == other.ScopeInfo
3075     }
3076 }
3077 impl ::std::cmp::Eq for DHCP_MIB_INFO {}
3078 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO {
3079     type Abi = Self;
3080     type DefaultType = Self;
3081 }
3082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3083 #[repr(C)]
3084 pub struct DHCP_MIB_INFO_V5 {
3085     pub Discovers: u32,
3086     pub Offers: u32,
3087     pub Requests: u32,
3088     pub Acks: u32,
3089     pub Naks: u32,
3090     pub Declines: u32,
3091     pub Releases: u32,
3092     pub ServerStartTime: DATE_TIME,
3093     pub QtnNumLeases: u32,
3094     pub QtnPctQtnLeases: u32,
3095     pub QtnProbationLeases: u32,
3096     pub QtnNonQtnLeases: u32,
3097     pub QtnExemptLeases: u32,
3098     pub QtnCapableClients: u32,
3099     pub QtnIASErrors: u32,
3100     pub DelayedOffers: u32,
3101     pub ScopesWithDelayedOffers: u32,
3102     pub Scopes: u32,
3103     pub ScopeInfo: *mut SCOPE_MIB_INFO_V5,
3104 }
3105 impl DHCP_MIB_INFO_V5 {}
3106 impl ::std::default::Default for DHCP_MIB_INFO_V5 {
default() -> Self3107     fn default() -> Self {
3108         unsafe { ::std::mem::zeroed() }
3109     }
3110 }
3111 impl ::std::fmt::Debug for DHCP_MIB_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3112     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3113         fmt.debug_struct("DHCP_MIB_INFO_V5")
3114             .field("Discovers", &self.Discovers)
3115             .field("Offers", &self.Offers)
3116             .field("Requests", &self.Requests)
3117             .field("Acks", &self.Acks)
3118             .field("Naks", &self.Naks)
3119             .field("Declines", &self.Declines)
3120             .field("Releases", &self.Releases)
3121             .field("ServerStartTime", &self.ServerStartTime)
3122             .field("QtnNumLeases", &self.QtnNumLeases)
3123             .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
3124             .field("QtnProbationLeases", &self.QtnProbationLeases)
3125             .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
3126             .field("QtnExemptLeases", &self.QtnExemptLeases)
3127             .field("QtnCapableClients", &self.QtnCapableClients)
3128             .field("QtnIASErrors", &self.QtnIASErrors)
3129             .field("DelayedOffers", &self.DelayedOffers)
3130             .field("ScopesWithDelayedOffers", &self.ScopesWithDelayedOffers)
3131             .field("Scopes", &self.Scopes)
3132             .field("ScopeInfo", &self.ScopeInfo)
3133             .finish()
3134     }
3135 }
3136 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_V5 {
eq(&self, other: &Self) -> bool3137     fn eq(&self, other: &Self) -> bool {
3138         self.Discovers == other.Discovers
3139             && self.Offers == other.Offers
3140             && self.Requests == other.Requests
3141             && self.Acks == other.Acks
3142             && self.Naks == other.Naks
3143             && self.Declines == other.Declines
3144             && self.Releases == other.Releases
3145             && self.ServerStartTime == other.ServerStartTime
3146             && self.QtnNumLeases == other.QtnNumLeases
3147             && self.QtnPctQtnLeases == other.QtnPctQtnLeases
3148             && self.QtnProbationLeases == other.QtnProbationLeases
3149             && self.QtnNonQtnLeases == other.QtnNonQtnLeases
3150             && self.QtnExemptLeases == other.QtnExemptLeases
3151             && self.QtnCapableClients == other.QtnCapableClients
3152             && self.QtnIASErrors == other.QtnIASErrors
3153             && self.DelayedOffers == other.DelayedOffers
3154             && self.ScopesWithDelayedOffers == other.ScopesWithDelayedOffers
3155             && self.Scopes == other.Scopes
3156             && self.ScopeInfo == other.ScopeInfo
3157     }
3158 }
3159 impl ::std::cmp::Eq for DHCP_MIB_INFO_V5 {}
3160 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_V5 {
3161     type Abi = Self;
3162     type DefaultType = Self;
3163 }
3164 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3165 #[repr(C)]
3166 pub struct DHCP_MIB_INFO_V6 {
3167     pub Solicits: u32,
3168     pub Advertises: u32,
3169     pub Requests: u32,
3170     pub Renews: u32,
3171     pub Rebinds: u32,
3172     pub Replies: u32,
3173     pub Confirms: u32,
3174     pub Declines: u32,
3175     pub Releases: u32,
3176     pub Informs: u32,
3177     pub ServerStartTime: DATE_TIME,
3178     pub Scopes: u32,
3179     pub ScopeInfo: *mut SCOPE_MIB_INFO_V6,
3180 }
3181 impl DHCP_MIB_INFO_V6 {}
3182 impl ::std::default::Default for DHCP_MIB_INFO_V6 {
default() -> Self3183     fn default() -> Self {
3184         unsafe { ::std::mem::zeroed() }
3185     }
3186 }
3187 impl ::std::fmt::Debug for DHCP_MIB_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3188     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3189         fmt.debug_struct("DHCP_MIB_INFO_V6")
3190             .field("Solicits", &self.Solicits)
3191             .field("Advertises", &self.Advertises)
3192             .field("Requests", &self.Requests)
3193             .field("Renews", &self.Renews)
3194             .field("Rebinds", &self.Rebinds)
3195             .field("Replies", &self.Replies)
3196             .field("Confirms", &self.Confirms)
3197             .field("Declines", &self.Declines)
3198             .field("Releases", &self.Releases)
3199             .field("Informs", &self.Informs)
3200             .field("ServerStartTime", &self.ServerStartTime)
3201             .field("Scopes", &self.Scopes)
3202             .field("ScopeInfo", &self.ScopeInfo)
3203             .finish()
3204     }
3205 }
3206 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_V6 {
eq(&self, other: &Self) -> bool3207     fn eq(&self, other: &Self) -> bool {
3208         self.Solicits == other.Solicits && self.Advertises == other.Advertises && self.Requests == other.Requests && self.Renews == other.Renews && self.Rebinds == other.Rebinds && self.Replies == other.Replies && self.Confirms == other.Confirms && self.Declines == other.Declines && self.Releases == other.Releases && self.Informs == other.Informs && self.ServerStartTime == other.ServerStartTime && self.Scopes == other.Scopes && self.ScopeInfo == other.ScopeInfo
3209     }
3210 }
3211 impl ::std::cmp::Eq for DHCP_MIB_INFO_V6 {}
3212 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_V6 {
3213     type Abi = Self;
3214     type DefaultType = Self;
3215 }
3216 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3217 #[repr(C)]
3218 pub struct DHCP_MIB_INFO_VQ {
3219     pub Discovers: u32,
3220     pub Offers: u32,
3221     pub Requests: u32,
3222     pub Acks: u32,
3223     pub Naks: u32,
3224     pub Declines: u32,
3225     pub Releases: u32,
3226     pub ServerStartTime: DATE_TIME,
3227     pub QtnNumLeases: u32,
3228     pub QtnPctQtnLeases: u32,
3229     pub QtnProbationLeases: u32,
3230     pub QtnNonQtnLeases: u32,
3231     pub QtnExemptLeases: u32,
3232     pub QtnCapableClients: u32,
3233     pub QtnIASErrors: u32,
3234     pub Scopes: u32,
3235     pub ScopeInfo: *mut SCOPE_MIB_INFO_VQ,
3236 }
3237 impl DHCP_MIB_INFO_VQ {}
3238 impl ::std::default::Default for DHCP_MIB_INFO_VQ {
default() -> Self3239     fn default() -> Self {
3240         unsafe { ::std::mem::zeroed() }
3241     }
3242 }
3243 impl ::std::fmt::Debug for DHCP_MIB_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3244     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3245         fmt.debug_struct("DHCP_MIB_INFO_VQ")
3246             .field("Discovers", &self.Discovers)
3247             .field("Offers", &self.Offers)
3248             .field("Requests", &self.Requests)
3249             .field("Acks", &self.Acks)
3250             .field("Naks", &self.Naks)
3251             .field("Declines", &self.Declines)
3252             .field("Releases", &self.Releases)
3253             .field("ServerStartTime", &self.ServerStartTime)
3254             .field("QtnNumLeases", &self.QtnNumLeases)
3255             .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
3256             .field("QtnProbationLeases", &self.QtnProbationLeases)
3257             .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
3258             .field("QtnExemptLeases", &self.QtnExemptLeases)
3259             .field("QtnCapableClients", &self.QtnCapableClients)
3260             .field("QtnIASErrors", &self.QtnIASErrors)
3261             .field("Scopes", &self.Scopes)
3262             .field("ScopeInfo", &self.ScopeInfo)
3263             .finish()
3264     }
3265 }
3266 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_VQ {
eq(&self, other: &Self) -> bool3267     fn eq(&self, other: &Self) -> bool {
3268         self.Discovers == other.Discovers
3269             && self.Offers == other.Offers
3270             && self.Requests == other.Requests
3271             && self.Acks == other.Acks
3272             && self.Naks == other.Naks
3273             && self.Declines == other.Declines
3274             && self.Releases == other.Releases
3275             && self.ServerStartTime == other.ServerStartTime
3276             && self.QtnNumLeases == other.QtnNumLeases
3277             && self.QtnPctQtnLeases == other.QtnPctQtnLeases
3278             && self.QtnProbationLeases == other.QtnProbationLeases
3279             && self.QtnNonQtnLeases == other.QtnNonQtnLeases
3280             && self.QtnExemptLeases == other.QtnExemptLeases
3281             && self.QtnCapableClients == other.QtnCapableClients
3282             && self.QtnIASErrors == other.QtnIASErrors
3283             && self.Scopes == other.Scopes
3284             && self.ScopeInfo == other.ScopeInfo
3285     }
3286 }
3287 impl ::std::cmp::Eq for DHCP_MIB_INFO_VQ {}
3288 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_VQ {
3289     type Abi = Self;
3290     type DefaultType = Self;
3291 }
3292 pub const DHCP_MIN_DELAY: u32 = 0u32;
3293 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3294 #[repr(C)]
3295 #[cfg(feature = "Win32_Foundation")]
3296 pub struct DHCP_OPTION {
3297     pub OptionID: u32,
3298     pub OptionName: super::super::Foundation::PWSTR,
3299     pub OptionComment: super::super::Foundation::PWSTR,
3300     pub DefaultValue: DHCP_OPTION_DATA,
3301     pub OptionType: DHCP_OPTION_TYPE,
3302 }
3303 #[cfg(feature = "Win32_Foundation")]
3304 impl DHCP_OPTION {}
3305 #[cfg(feature = "Win32_Foundation")]
3306 impl ::std::default::Default for DHCP_OPTION {
default() -> Self3307     fn default() -> Self {
3308         unsafe { ::std::mem::zeroed() }
3309     }
3310 }
3311 #[cfg(feature = "Win32_Foundation")]
3312 impl ::std::fmt::Debug for DHCP_OPTION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3313     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3314         fmt.debug_struct("DHCP_OPTION").field("OptionID", &self.OptionID).field("OptionName", &self.OptionName).field("OptionComment", &self.OptionComment).field("DefaultValue", &self.DefaultValue).field("OptionType", &self.OptionType).finish()
3315     }
3316 }
3317 #[cfg(feature = "Win32_Foundation")]
3318 impl ::std::cmp::PartialEq for DHCP_OPTION {
eq(&self, other: &Self) -> bool3319     fn eq(&self, other: &Self) -> bool {
3320         self.OptionID == other.OptionID && self.OptionName == other.OptionName && self.OptionComment == other.OptionComment && self.DefaultValue == other.DefaultValue && self.OptionType == other.OptionType
3321     }
3322 }
3323 #[cfg(feature = "Win32_Foundation")]
3324 impl ::std::cmp::Eq for DHCP_OPTION {}
3325 #[cfg(feature = "Win32_Foundation")]
3326 unsafe impl ::windows::runtime::Abi for DHCP_OPTION {
3327     type Abi = Self;
3328     type DefaultType = Self;
3329 }
3330 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3331 #[repr(C)]
3332 #[cfg(feature = "Win32_Foundation")]
3333 pub struct DHCP_OPTION_ARRAY {
3334     pub NumElements: u32,
3335     pub Options: *mut DHCP_OPTION,
3336 }
3337 #[cfg(feature = "Win32_Foundation")]
3338 impl DHCP_OPTION_ARRAY {}
3339 #[cfg(feature = "Win32_Foundation")]
3340 impl ::std::default::Default for DHCP_OPTION_ARRAY {
default() -> Self3341     fn default() -> Self {
3342         unsafe { ::std::mem::zeroed() }
3343     }
3344 }
3345 #[cfg(feature = "Win32_Foundation")]
3346 impl ::std::fmt::Debug for DHCP_OPTION_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3347     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3348         fmt.debug_struct("DHCP_OPTION_ARRAY").field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
3349     }
3350 }
3351 #[cfg(feature = "Win32_Foundation")]
3352 impl ::std::cmp::PartialEq for DHCP_OPTION_ARRAY {
eq(&self, other: &Self) -> bool3353     fn eq(&self, other: &Self) -> bool {
3354         self.NumElements == other.NumElements && self.Options == other.Options
3355     }
3356 }
3357 #[cfg(feature = "Win32_Foundation")]
3358 impl ::std::cmp::Eq for DHCP_OPTION_ARRAY {}
3359 #[cfg(feature = "Win32_Foundation")]
3360 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_ARRAY {
3361     type Abi = Self;
3362     type DefaultType = Self;
3363 }
3364 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3365 #[repr(C)]
3366 #[cfg(feature = "Win32_Foundation")]
3367 pub struct DHCP_OPTION_DATA {
3368     pub NumElements: u32,
3369     pub Elements: *mut DHCP_OPTION_DATA_ELEMENT,
3370 }
3371 #[cfg(feature = "Win32_Foundation")]
3372 impl DHCP_OPTION_DATA {}
3373 #[cfg(feature = "Win32_Foundation")]
3374 impl ::std::default::Default for DHCP_OPTION_DATA {
default() -> Self3375     fn default() -> Self {
3376         unsafe { ::std::mem::zeroed() }
3377     }
3378 }
3379 #[cfg(feature = "Win32_Foundation")]
3380 impl ::std::fmt::Debug for DHCP_OPTION_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3381     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3382         fmt.debug_struct("DHCP_OPTION_DATA").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3383     }
3384 }
3385 #[cfg(feature = "Win32_Foundation")]
3386 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA {
eq(&self, other: &Self) -> bool3387     fn eq(&self, other: &Self) -> bool {
3388         self.NumElements == other.NumElements && self.Elements == other.Elements
3389     }
3390 }
3391 #[cfg(feature = "Win32_Foundation")]
3392 impl ::std::cmp::Eq for DHCP_OPTION_DATA {}
3393 #[cfg(feature = "Win32_Foundation")]
3394 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA {
3395     type Abi = Self;
3396     type DefaultType = Self;
3397 }
3398 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3399 #[repr(C)]
3400 #[cfg(feature = "Win32_Foundation")]
3401 pub struct DHCP_OPTION_DATA_ELEMENT {
3402     pub OptionType: DHCP_OPTION_DATA_TYPE,
3403     pub Element: DHCP_OPTION_DATA_ELEMENT_0,
3404 }
3405 #[cfg(feature = "Win32_Foundation")]
3406 impl DHCP_OPTION_DATA_ELEMENT {}
3407 #[cfg(feature = "Win32_Foundation")]
3408 impl ::std::default::Default for DHCP_OPTION_DATA_ELEMENT {
default() -> Self3409     fn default() -> Self {
3410         unsafe { ::std::mem::zeroed() }
3411     }
3412 }
3413 #[cfg(feature = "Win32_Foundation")]
3414 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA_ELEMENT {
eq(&self, _other: &Self) -> bool3415     fn eq(&self, _other: &Self) -> bool {
3416         unimplemented!()
3417     }
3418 }
3419 #[cfg(feature = "Win32_Foundation")]
3420 impl ::std::cmp::Eq for DHCP_OPTION_DATA_ELEMENT {}
3421 #[cfg(feature = "Win32_Foundation")]
3422 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_ELEMENT {
3423     type Abi = Self;
3424     type DefaultType = Self;
3425 }
3426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3427 #[repr(C)]
3428 #[cfg(feature = "Win32_Foundation")]
3429 pub union DHCP_OPTION_DATA_ELEMENT_0 {
3430     pub ByteOption: u8,
3431     pub WordOption: u16,
3432     pub DWordOption: u32,
3433     pub DWordDWordOption: DWORD_DWORD,
3434     pub IpAddressOption: u32,
3435     pub StringDataOption: super::super::Foundation::PWSTR,
3436     pub BinaryDataOption: DHCP_BINARY_DATA,
3437     pub EncapsulatedDataOption: DHCP_BINARY_DATA,
3438     pub Ipv6AddressDataOption: super::super::Foundation::PWSTR,
3439 }
3440 #[cfg(feature = "Win32_Foundation")]
3441 impl DHCP_OPTION_DATA_ELEMENT_0 {}
3442 #[cfg(feature = "Win32_Foundation")]
3443 impl ::std::default::Default for DHCP_OPTION_DATA_ELEMENT_0 {
default() -> Self3444     fn default() -> Self {
3445         unsafe { ::std::mem::zeroed() }
3446     }
3447 }
3448 #[cfg(feature = "Win32_Foundation")]
3449 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA_ELEMENT_0 {
eq(&self, _other: &Self) -> bool3450     fn eq(&self, _other: &Self) -> bool {
3451         unimplemented!()
3452     }
3453 }
3454 #[cfg(feature = "Win32_Foundation")]
3455 impl ::std::cmp::Eq for DHCP_OPTION_DATA_ELEMENT_0 {}
3456 #[cfg(feature = "Win32_Foundation")]
3457 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_ELEMENT_0 {
3458     type Abi = Self;
3459     type DefaultType = Self;
3460 }
3461 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3462 #[repr(transparent)]
3463 pub struct DHCP_OPTION_DATA_TYPE(pub i32);
3464 pub const DhcpByteOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(0i32);
3465 pub const DhcpWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(1i32);
3466 pub const DhcpDWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(2i32);
3467 pub const DhcpDWordDWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(3i32);
3468 pub const DhcpIpAddressOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(4i32);
3469 pub const DhcpStringDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(5i32);
3470 pub const DhcpBinaryDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(6i32);
3471 pub const DhcpEncapsulatedDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(7i32);
3472 pub const DhcpIpv6AddressOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(8i32);
3473 impl ::std::convert::From<i32> for DHCP_OPTION_DATA_TYPE {
from(value: i32) -> Self3474     fn from(value: i32) -> Self {
3475         Self(value)
3476     }
3477 }
3478 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_TYPE {
3479     type Abi = Self;
3480     type DefaultType = Self;
3481 }
3482 #[repr(C)]
3483 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
3484 pub struct DHCP_OPTION_ELEMENT_UNION(pub u8);
3485 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3486 #[repr(C)]
3487 #[cfg(feature = "Win32_Foundation")]
3488 pub struct DHCP_OPTION_LIST {
3489     pub NumOptions: u32,
3490     pub Options: *mut DHCP_OPTION_VALUE,
3491 }
3492 #[cfg(feature = "Win32_Foundation")]
3493 impl DHCP_OPTION_LIST {}
3494 #[cfg(feature = "Win32_Foundation")]
3495 impl ::std::default::Default for DHCP_OPTION_LIST {
default() -> Self3496     fn default() -> Self {
3497         unsafe { ::std::mem::zeroed() }
3498     }
3499 }
3500 #[cfg(feature = "Win32_Foundation")]
3501 impl ::std::fmt::Debug for DHCP_OPTION_LIST {
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("DHCP_OPTION_LIST").field("NumOptions", &self.NumOptions).field("Options", &self.Options).finish()
3504     }
3505 }
3506 #[cfg(feature = "Win32_Foundation")]
3507 impl ::std::cmp::PartialEq for DHCP_OPTION_LIST {
eq(&self, other: &Self) -> bool3508     fn eq(&self, other: &Self) -> bool {
3509         self.NumOptions == other.NumOptions && self.Options == other.Options
3510     }
3511 }
3512 #[cfg(feature = "Win32_Foundation")]
3513 impl ::std::cmp::Eq for DHCP_OPTION_LIST {}
3514 #[cfg(feature = "Win32_Foundation")]
3515 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_LIST {
3516     type Abi = Self;
3517     type DefaultType = Self;
3518 }
3519 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3520 #[repr(C)]
3521 #[cfg(feature = "Win32_Foundation")]
3522 pub struct DHCP_OPTION_SCOPE_INFO {
3523     pub ScopeType: DHCP_OPTION_SCOPE_TYPE,
3524     pub ScopeInfo: DHCP_OPTION_SCOPE_INFO_0,
3525 }
3526 #[cfg(feature = "Win32_Foundation")]
3527 impl DHCP_OPTION_SCOPE_INFO {}
3528 #[cfg(feature = "Win32_Foundation")]
3529 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO {
default() -> Self3530     fn default() -> Self {
3531         unsafe { ::std::mem::zeroed() }
3532     }
3533 }
3534 #[cfg(feature = "Win32_Foundation")]
3535 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO {
eq(&self, _other: &Self) -> bool3536     fn eq(&self, _other: &Self) -> bool {
3537         unimplemented!()
3538     }
3539 }
3540 #[cfg(feature = "Win32_Foundation")]
3541 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO {}
3542 #[cfg(feature = "Win32_Foundation")]
3543 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO {
3544     type Abi = Self;
3545     type DefaultType = Self;
3546 }
3547 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3548 #[repr(C)]
3549 #[cfg(feature = "Win32_Foundation")]
3550 pub union DHCP_OPTION_SCOPE_INFO_0 {
3551     pub DefaultScopeInfo: *mut ::std::ffi::c_void,
3552     pub GlobalScopeInfo: *mut ::std::ffi::c_void,
3553     pub SubnetScopeInfo: u32,
3554     pub ReservedScopeInfo: DHCP_RESERVED_SCOPE,
3555     pub MScopeInfo: super::super::Foundation::PWSTR,
3556 }
3557 #[cfg(feature = "Win32_Foundation")]
3558 impl DHCP_OPTION_SCOPE_INFO_0 {}
3559 #[cfg(feature = "Win32_Foundation")]
3560 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO_0 {
default() -> Self3561     fn default() -> Self {
3562         unsafe { ::std::mem::zeroed() }
3563     }
3564 }
3565 #[cfg(feature = "Win32_Foundation")]
3566 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO_0 {
eq(&self, _other: &Self) -> bool3567     fn eq(&self, _other: &Self) -> bool {
3568         unimplemented!()
3569     }
3570 }
3571 #[cfg(feature = "Win32_Foundation")]
3572 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO_0 {}
3573 #[cfg(feature = "Win32_Foundation")]
3574 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO_0 {
3575     type Abi = Self;
3576     type DefaultType = Self;
3577 }
3578 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3579 #[repr(C)]
3580 pub struct DHCP_OPTION_SCOPE_INFO6 {
3581     pub ScopeType: DHCP_OPTION_SCOPE_TYPE6,
3582     pub ScopeInfo: DHCP_OPTION_SCOPE_INFO6_0,
3583 }
3584 impl DHCP_OPTION_SCOPE_INFO6 {}
3585 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO6 {
default() -> Self3586     fn default() -> Self {
3587         unsafe { ::std::mem::zeroed() }
3588     }
3589 }
3590 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO6 {
eq(&self, _other: &Self) -> bool3591     fn eq(&self, _other: &Self) -> bool {
3592         unimplemented!()
3593     }
3594 }
3595 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO6 {}
3596 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO6 {
3597     type Abi = Self;
3598     type DefaultType = Self;
3599 }
3600 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3601 #[repr(C)]
3602 pub union DHCP_OPTION_SCOPE_INFO6_0 {
3603     pub DefaultScopeInfo: *mut ::std::ffi::c_void,
3604     pub SubnetScopeInfo: DHCP_IPV6_ADDRESS,
3605     pub ReservedScopeInfo: DHCP_RESERVED_SCOPE6,
3606 }
3607 impl DHCP_OPTION_SCOPE_INFO6_0 {}
3608 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO6_0 {
default() -> Self3609     fn default() -> Self {
3610         unsafe { ::std::mem::zeroed() }
3611     }
3612 }
3613 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO6_0 {
eq(&self, _other: &Self) -> bool3614     fn eq(&self, _other: &Self) -> bool {
3615         unimplemented!()
3616     }
3617 }
3618 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO6_0 {}
3619 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO6_0 {
3620     type Abi = Self;
3621     type DefaultType = Self;
3622 }
3623 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3624 #[repr(transparent)]
3625 pub struct DHCP_OPTION_SCOPE_TYPE(pub i32);
3626 pub const DhcpDefaultOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(0i32);
3627 pub const DhcpGlobalOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(1i32);
3628 pub const DhcpSubnetOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(2i32);
3629 pub const DhcpReservedOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(3i32);
3630 pub const DhcpMScopeOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(4i32);
3631 impl ::std::convert::From<i32> for DHCP_OPTION_SCOPE_TYPE {
from(value: i32) -> Self3632     fn from(value: i32) -> Self {
3633         Self(value)
3634     }
3635 }
3636 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_TYPE {
3637     type Abi = Self;
3638     type DefaultType = Self;
3639 }
3640 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3641 #[repr(transparent)]
3642 pub struct DHCP_OPTION_SCOPE_TYPE6(pub i32);
3643 pub const DhcpDefaultOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(0i32);
3644 pub const DhcpScopeOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(1i32);
3645 pub const DhcpReservedOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(2i32);
3646 pub const DhcpGlobalOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(3i32);
3647 impl ::std::convert::From<i32> for DHCP_OPTION_SCOPE_TYPE6 {
from(value: i32) -> Self3648     fn from(value: i32) -> Self {
3649         Self(value)
3650     }
3651 }
3652 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_TYPE6 {
3653     type Abi = Self;
3654     type DefaultType = Self;
3655 }
3656 #[repr(C)]
3657 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
3658 pub struct DHCP_OPTION_SCOPE_UNION6(pub u8);
3659 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3660 #[repr(transparent)]
3661 pub struct DHCP_OPTION_TYPE(pub i32);
3662 pub const DhcpUnaryElementTypeOption: DHCP_OPTION_TYPE = DHCP_OPTION_TYPE(0i32);
3663 pub const DhcpArrayTypeOption: DHCP_OPTION_TYPE = DHCP_OPTION_TYPE(1i32);
3664 impl ::std::convert::From<i32> for DHCP_OPTION_TYPE {
from(value: i32) -> Self3665     fn from(value: i32) -> Self {
3666         Self(value)
3667     }
3668 }
3669 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_TYPE {
3670     type Abi = Self;
3671     type DefaultType = Self;
3672 }
3673 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3674 #[repr(C)]
3675 #[cfg(feature = "Win32_Foundation")]
3676 pub struct DHCP_OPTION_VALUE {
3677     pub OptionID: u32,
3678     pub Value: DHCP_OPTION_DATA,
3679 }
3680 #[cfg(feature = "Win32_Foundation")]
3681 impl DHCP_OPTION_VALUE {}
3682 #[cfg(feature = "Win32_Foundation")]
3683 impl ::std::default::Default for DHCP_OPTION_VALUE {
default() -> Self3684     fn default() -> Self {
3685         unsafe { ::std::mem::zeroed() }
3686     }
3687 }
3688 #[cfg(feature = "Win32_Foundation")]
3689 impl ::std::fmt::Debug for DHCP_OPTION_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3690     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3691         fmt.debug_struct("DHCP_OPTION_VALUE").field("OptionID", &self.OptionID).field("Value", &self.Value).finish()
3692     }
3693 }
3694 #[cfg(feature = "Win32_Foundation")]
3695 impl ::std::cmp::PartialEq for DHCP_OPTION_VALUE {
eq(&self, other: &Self) -> bool3696     fn eq(&self, other: &Self) -> bool {
3697         self.OptionID == other.OptionID && self.Value == other.Value
3698     }
3699 }
3700 #[cfg(feature = "Win32_Foundation")]
3701 impl ::std::cmp::Eq for DHCP_OPTION_VALUE {}
3702 #[cfg(feature = "Win32_Foundation")]
3703 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_VALUE {
3704     type Abi = Self;
3705     type DefaultType = Self;
3706 }
3707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3708 #[repr(C)]
3709 #[cfg(feature = "Win32_Foundation")]
3710 pub struct DHCP_OPTION_VALUE_ARRAY {
3711     pub NumElements: u32,
3712     pub Values: *mut DHCP_OPTION_VALUE,
3713 }
3714 #[cfg(feature = "Win32_Foundation")]
3715 impl DHCP_OPTION_VALUE_ARRAY {}
3716 #[cfg(feature = "Win32_Foundation")]
3717 impl ::std::default::Default for DHCP_OPTION_VALUE_ARRAY {
default() -> Self3718     fn default() -> Self {
3719         unsafe { ::std::mem::zeroed() }
3720     }
3721 }
3722 #[cfg(feature = "Win32_Foundation")]
3723 impl ::std::fmt::Debug for DHCP_OPTION_VALUE_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3724     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3725         fmt.debug_struct("DHCP_OPTION_VALUE_ARRAY").field("NumElements", &self.NumElements).field("Values", &self.Values).finish()
3726     }
3727 }
3728 #[cfg(feature = "Win32_Foundation")]
3729 impl ::std::cmp::PartialEq for DHCP_OPTION_VALUE_ARRAY {
eq(&self, other: &Self) -> bool3730     fn eq(&self, other: &Self) -> bool {
3731         self.NumElements == other.NumElements && self.Values == other.Values
3732     }
3733 }
3734 #[cfg(feature = "Win32_Foundation")]
3735 impl ::std::cmp::Eq for DHCP_OPTION_VALUE_ARRAY {}
3736 #[cfg(feature = "Win32_Foundation")]
3737 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_VALUE_ARRAY {
3738     type Abi = Self;
3739     type DefaultType = Self;
3740 }
3741 pub const DHCP_OPT_ENUM_IGNORE_VENDOR: u32 = 1u32;
3742 pub const DHCP_OPT_ENUM_USE_CLASSNAME: u32 = 2u32;
3743 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3744 #[repr(C)]
3745 pub struct DHCP_PERF_STATS {
3746     pub dwNumPacketsReceived: u32,
3747     pub dwNumPacketsDuplicate: u32,
3748     pub dwNumPacketsExpired: u32,
3749     pub dwNumMilliSecondsProcessed: u32,
3750     pub dwNumPacketsInActiveQueue: u32,
3751     pub dwNumPacketsInPingQueue: u32,
3752     pub dwNumDiscoversReceived: u32,
3753     pub dwNumOffersSent: u32,
3754     pub dwNumRequestsReceived: u32,
3755     pub dwNumInformsReceived: u32,
3756     pub dwNumAcksSent: u32,
3757     pub dwNumNacksSent: u32,
3758     pub dwNumDeclinesReceived: u32,
3759     pub dwNumReleasesReceived: u32,
3760     pub dwNumDelayedOfferInQueue: u32,
3761     pub dwNumPacketsProcessed: u32,
3762     pub dwNumPacketsInQuarWaitingQueue: u32,
3763     pub dwNumPacketsInQuarReadyQueue: u32,
3764     pub dwNumPacketsInQuarDecisionQueue: u32,
3765 }
3766 impl DHCP_PERF_STATS {}
3767 impl ::std::default::Default for DHCP_PERF_STATS {
default() -> Self3768     fn default() -> Self {
3769         unsafe { ::std::mem::zeroed() }
3770     }
3771 }
3772 impl ::std::fmt::Debug for DHCP_PERF_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3773     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3774         fmt.debug_struct("DHCP_PERF_STATS")
3775             .field("dwNumPacketsReceived", &self.dwNumPacketsReceived)
3776             .field("dwNumPacketsDuplicate", &self.dwNumPacketsDuplicate)
3777             .field("dwNumPacketsExpired", &self.dwNumPacketsExpired)
3778             .field("dwNumMilliSecondsProcessed", &self.dwNumMilliSecondsProcessed)
3779             .field("dwNumPacketsInActiveQueue", &self.dwNumPacketsInActiveQueue)
3780             .field("dwNumPacketsInPingQueue", &self.dwNumPacketsInPingQueue)
3781             .field("dwNumDiscoversReceived", &self.dwNumDiscoversReceived)
3782             .field("dwNumOffersSent", &self.dwNumOffersSent)
3783             .field("dwNumRequestsReceived", &self.dwNumRequestsReceived)
3784             .field("dwNumInformsReceived", &self.dwNumInformsReceived)
3785             .field("dwNumAcksSent", &self.dwNumAcksSent)
3786             .field("dwNumNacksSent", &self.dwNumNacksSent)
3787             .field("dwNumDeclinesReceived", &self.dwNumDeclinesReceived)
3788             .field("dwNumReleasesReceived", &self.dwNumReleasesReceived)
3789             .field("dwNumDelayedOfferInQueue", &self.dwNumDelayedOfferInQueue)
3790             .field("dwNumPacketsProcessed", &self.dwNumPacketsProcessed)
3791             .field("dwNumPacketsInQuarWaitingQueue", &self.dwNumPacketsInQuarWaitingQueue)
3792             .field("dwNumPacketsInQuarReadyQueue", &self.dwNumPacketsInQuarReadyQueue)
3793             .field("dwNumPacketsInQuarDecisionQueue", &self.dwNumPacketsInQuarDecisionQueue)
3794             .finish()
3795     }
3796 }
3797 impl ::std::cmp::PartialEq for DHCP_PERF_STATS {
eq(&self, other: &Self) -> bool3798     fn eq(&self, other: &Self) -> bool {
3799         self.dwNumPacketsReceived == other.dwNumPacketsReceived
3800             && self.dwNumPacketsDuplicate == other.dwNumPacketsDuplicate
3801             && self.dwNumPacketsExpired == other.dwNumPacketsExpired
3802             && self.dwNumMilliSecondsProcessed == other.dwNumMilliSecondsProcessed
3803             && self.dwNumPacketsInActiveQueue == other.dwNumPacketsInActiveQueue
3804             && self.dwNumPacketsInPingQueue == other.dwNumPacketsInPingQueue
3805             && self.dwNumDiscoversReceived == other.dwNumDiscoversReceived
3806             && self.dwNumOffersSent == other.dwNumOffersSent
3807             && self.dwNumRequestsReceived == other.dwNumRequestsReceived
3808             && self.dwNumInformsReceived == other.dwNumInformsReceived
3809             && self.dwNumAcksSent == other.dwNumAcksSent
3810             && self.dwNumNacksSent == other.dwNumNacksSent
3811             && self.dwNumDeclinesReceived == other.dwNumDeclinesReceived
3812             && self.dwNumReleasesReceived == other.dwNumReleasesReceived
3813             && self.dwNumDelayedOfferInQueue == other.dwNumDelayedOfferInQueue
3814             && self.dwNumPacketsProcessed == other.dwNumPacketsProcessed
3815             && self.dwNumPacketsInQuarWaitingQueue == other.dwNumPacketsInQuarWaitingQueue
3816             && self.dwNumPacketsInQuarReadyQueue == other.dwNumPacketsInQuarReadyQueue
3817             && self.dwNumPacketsInQuarDecisionQueue == other.dwNumPacketsInQuarDecisionQueue
3818     }
3819 }
3820 impl ::std::cmp::Eq for DHCP_PERF_STATS {}
3821 unsafe impl ::windows::runtime::Abi for DHCP_PERF_STATS {
3822     type Abi = Self;
3823     type DefaultType = Self;
3824 }
3825 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3826 #[repr(C)]
3827 #[cfg(feature = "Win32_Foundation")]
3828 pub struct DHCP_POLICY {
3829     pub PolicyName: super::super::Foundation::PWSTR,
3830     pub IsGlobalPolicy: super::super::Foundation::BOOL,
3831     pub Subnet: u32,
3832     pub ProcessingOrder: u32,
3833     pub Conditions: *mut DHCP_POL_COND_ARRAY,
3834     pub Expressions: *mut DHCP_POL_EXPR_ARRAY,
3835     pub Ranges: *mut DHCP_IP_RANGE_ARRAY,
3836     pub Description: super::super::Foundation::PWSTR,
3837     pub Enabled: super::super::Foundation::BOOL,
3838 }
3839 #[cfg(feature = "Win32_Foundation")]
3840 impl DHCP_POLICY {}
3841 #[cfg(feature = "Win32_Foundation")]
3842 impl ::std::default::Default for DHCP_POLICY {
default() -> Self3843     fn default() -> Self {
3844         unsafe { ::std::mem::zeroed() }
3845     }
3846 }
3847 #[cfg(feature = "Win32_Foundation")]
3848 impl ::std::fmt::Debug for DHCP_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3849     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3850         fmt.debug_struct("DHCP_POLICY")
3851             .field("PolicyName", &self.PolicyName)
3852             .field("IsGlobalPolicy", &self.IsGlobalPolicy)
3853             .field("Subnet", &self.Subnet)
3854             .field("ProcessingOrder", &self.ProcessingOrder)
3855             .field("Conditions", &self.Conditions)
3856             .field("Expressions", &self.Expressions)
3857             .field("Ranges", &self.Ranges)
3858             .field("Description", &self.Description)
3859             .field("Enabled", &self.Enabled)
3860             .finish()
3861     }
3862 }
3863 #[cfg(feature = "Win32_Foundation")]
3864 impl ::std::cmp::PartialEq for DHCP_POLICY {
eq(&self, other: &Self) -> bool3865     fn eq(&self, other: &Self) -> bool {
3866         self.PolicyName == other.PolicyName && self.IsGlobalPolicy == other.IsGlobalPolicy && self.Subnet == other.Subnet && self.ProcessingOrder == other.ProcessingOrder && self.Conditions == other.Conditions && self.Expressions == other.Expressions && self.Ranges == other.Ranges && self.Description == other.Description && self.Enabled == other.Enabled
3867     }
3868 }
3869 #[cfg(feature = "Win32_Foundation")]
3870 impl ::std::cmp::Eq for DHCP_POLICY {}
3871 #[cfg(feature = "Win32_Foundation")]
3872 unsafe impl ::windows::runtime::Abi for DHCP_POLICY {
3873     type Abi = Self;
3874     type DefaultType = Self;
3875 }
3876 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3877 #[repr(C)]
3878 #[cfg(feature = "Win32_Foundation")]
3879 pub struct DHCP_POLICY_ARRAY {
3880     pub NumElements: u32,
3881     pub Elements: *mut DHCP_POLICY,
3882 }
3883 #[cfg(feature = "Win32_Foundation")]
3884 impl DHCP_POLICY_ARRAY {}
3885 #[cfg(feature = "Win32_Foundation")]
3886 impl ::std::default::Default for DHCP_POLICY_ARRAY {
default() -> Self3887     fn default() -> Self {
3888         unsafe { ::std::mem::zeroed() }
3889     }
3890 }
3891 #[cfg(feature = "Win32_Foundation")]
3892 impl ::std::fmt::Debug for DHCP_POLICY_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3893     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3894         fmt.debug_struct("DHCP_POLICY_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3895     }
3896 }
3897 #[cfg(feature = "Win32_Foundation")]
3898 impl ::std::cmp::PartialEq for DHCP_POLICY_ARRAY {
eq(&self, other: &Self) -> bool3899     fn eq(&self, other: &Self) -> bool {
3900         self.NumElements == other.NumElements && self.Elements == other.Elements
3901     }
3902 }
3903 #[cfg(feature = "Win32_Foundation")]
3904 impl ::std::cmp::Eq for DHCP_POLICY_ARRAY {}
3905 #[cfg(feature = "Win32_Foundation")]
3906 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_ARRAY {
3907     type Abi = Self;
3908     type DefaultType = Self;
3909 }
3910 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3911 #[repr(C)]
3912 #[cfg(feature = "Win32_Foundation")]
3913 pub struct DHCP_POLICY_EX {
3914     pub PolicyName: super::super::Foundation::PWSTR,
3915     pub IsGlobalPolicy: super::super::Foundation::BOOL,
3916     pub Subnet: u32,
3917     pub ProcessingOrder: u32,
3918     pub Conditions: *mut DHCP_POL_COND_ARRAY,
3919     pub Expressions: *mut DHCP_POL_EXPR_ARRAY,
3920     pub Ranges: *mut DHCP_IP_RANGE_ARRAY,
3921     pub Description: super::super::Foundation::PWSTR,
3922     pub Enabled: super::super::Foundation::BOOL,
3923     pub Properties: *mut DHCP_PROPERTY_ARRAY,
3924 }
3925 #[cfg(feature = "Win32_Foundation")]
3926 impl DHCP_POLICY_EX {}
3927 #[cfg(feature = "Win32_Foundation")]
3928 impl ::std::default::Default for DHCP_POLICY_EX {
default() -> Self3929     fn default() -> Self {
3930         unsafe { ::std::mem::zeroed() }
3931     }
3932 }
3933 #[cfg(feature = "Win32_Foundation")]
3934 impl ::std::fmt::Debug for DHCP_POLICY_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3935     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3936         fmt.debug_struct("DHCP_POLICY_EX")
3937             .field("PolicyName", &self.PolicyName)
3938             .field("IsGlobalPolicy", &self.IsGlobalPolicy)
3939             .field("Subnet", &self.Subnet)
3940             .field("ProcessingOrder", &self.ProcessingOrder)
3941             .field("Conditions", &self.Conditions)
3942             .field("Expressions", &self.Expressions)
3943             .field("Ranges", &self.Ranges)
3944             .field("Description", &self.Description)
3945             .field("Enabled", &self.Enabled)
3946             .field("Properties", &self.Properties)
3947             .finish()
3948     }
3949 }
3950 #[cfg(feature = "Win32_Foundation")]
3951 impl ::std::cmp::PartialEq for DHCP_POLICY_EX {
eq(&self, other: &Self) -> bool3952     fn eq(&self, other: &Self) -> bool {
3953         self.PolicyName == other.PolicyName && self.IsGlobalPolicy == other.IsGlobalPolicy && self.Subnet == other.Subnet && self.ProcessingOrder == other.ProcessingOrder && self.Conditions == other.Conditions && self.Expressions == other.Expressions && self.Ranges == other.Ranges && self.Description == other.Description && self.Enabled == other.Enabled && self.Properties == other.Properties
3954     }
3955 }
3956 #[cfg(feature = "Win32_Foundation")]
3957 impl ::std::cmp::Eq for DHCP_POLICY_EX {}
3958 #[cfg(feature = "Win32_Foundation")]
3959 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_EX {
3960     type Abi = Self;
3961     type DefaultType = Self;
3962 }
3963 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3964 #[repr(C)]
3965 #[cfg(feature = "Win32_Foundation")]
3966 pub struct DHCP_POLICY_EX_ARRAY {
3967     pub NumElements: u32,
3968     pub Elements: *mut DHCP_POLICY_EX,
3969 }
3970 #[cfg(feature = "Win32_Foundation")]
3971 impl DHCP_POLICY_EX_ARRAY {}
3972 #[cfg(feature = "Win32_Foundation")]
3973 impl ::std::default::Default for DHCP_POLICY_EX_ARRAY {
default() -> Self3974     fn default() -> Self {
3975         unsafe { ::std::mem::zeroed() }
3976     }
3977 }
3978 #[cfg(feature = "Win32_Foundation")]
3979 impl ::std::fmt::Debug for DHCP_POLICY_EX_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3980     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3981         fmt.debug_struct("DHCP_POLICY_EX_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3982     }
3983 }
3984 #[cfg(feature = "Win32_Foundation")]
3985 impl ::std::cmp::PartialEq for DHCP_POLICY_EX_ARRAY {
eq(&self, other: &Self) -> bool3986     fn eq(&self, other: &Self) -> bool {
3987         self.NumElements == other.NumElements && self.Elements == other.Elements
3988     }
3989 }
3990 #[cfg(feature = "Win32_Foundation")]
3991 impl ::std::cmp::Eq for DHCP_POLICY_EX_ARRAY {}
3992 #[cfg(feature = "Win32_Foundation")]
3993 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_EX_ARRAY {
3994     type Abi = Self;
3995     type DefaultType = Self;
3996 }
3997 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3998 #[repr(transparent)]
3999 pub struct DHCP_POLICY_FIELDS_TO_UPDATE(pub i32);
4000 pub const DhcpUpdatePolicyName: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(1i32);
4001 pub const DhcpUpdatePolicyOrder: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(2i32);
4002 pub const DhcpUpdatePolicyExpr: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(4i32);
4003 pub const DhcpUpdatePolicyRanges: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(8i32);
4004 pub const DhcpUpdatePolicyDescr: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(16i32);
4005 pub const DhcpUpdatePolicyStatus: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(32i32);
4006 pub const DhcpUpdatePolicyDnsSuffix: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(64i32);
4007 impl ::std::convert::From<i32> for DHCP_POLICY_FIELDS_TO_UPDATE {
from(value: i32) -> Self4008     fn from(value: i32) -> Self {
4009         Self(value)
4010     }
4011 }
4012 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_FIELDS_TO_UPDATE {
4013     type Abi = Self;
4014     type DefaultType = Self;
4015 }
4016 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4017 #[repr(transparent)]
4018 pub struct DHCP_POL_ATTR_TYPE(pub i32);
4019 pub const DhcpAttrHWAddr: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(0i32);
4020 pub const DhcpAttrOption: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(1i32);
4021 pub const DhcpAttrSubOption: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(2i32);
4022 pub const DhcpAttrFqdn: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(3i32);
4023 pub const DhcpAttrFqdnSingleLabel: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(4i32);
4024 impl ::std::convert::From<i32> for DHCP_POL_ATTR_TYPE {
from(value: i32) -> Self4025     fn from(value: i32) -> Self {
4026         Self(value)
4027     }
4028 }
4029 unsafe impl ::windows::runtime::Abi for DHCP_POL_ATTR_TYPE {
4030     type Abi = Self;
4031     type DefaultType = Self;
4032 }
4033 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4034 #[repr(transparent)]
4035 pub struct DHCP_POL_COMPARATOR(pub i32);
4036 pub const DhcpCompEqual: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(0i32);
4037 pub const DhcpCompNotEqual: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(1i32);
4038 pub const DhcpCompBeginsWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(2i32);
4039 pub const DhcpCompNotBeginWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(3i32);
4040 pub const DhcpCompEndsWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(4i32);
4041 pub const DhcpCompNotEndWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(5i32);
4042 impl ::std::convert::From<i32> for DHCP_POL_COMPARATOR {
from(value: i32) -> Self4043     fn from(value: i32) -> Self {
4044         Self(value)
4045     }
4046 }
4047 unsafe impl ::windows::runtime::Abi for DHCP_POL_COMPARATOR {
4048     type Abi = Self;
4049     type DefaultType = Self;
4050 }
4051 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4052 #[repr(C)]
4053 #[cfg(feature = "Win32_Foundation")]
4054 pub struct DHCP_POL_COND {
4055     pub ParentExpr: u32,
4056     pub Type: DHCP_POL_ATTR_TYPE,
4057     pub OptionID: u32,
4058     pub SubOptionID: u32,
4059     pub VendorName: super::super::Foundation::PWSTR,
4060     pub Operator: DHCP_POL_COMPARATOR,
4061     pub Value: *mut u8,
4062     pub ValueLength: u32,
4063 }
4064 #[cfg(feature = "Win32_Foundation")]
4065 impl DHCP_POL_COND {}
4066 #[cfg(feature = "Win32_Foundation")]
4067 impl ::std::default::Default for DHCP_POL_COND {
default() -> Self4068     fn default() -> Self {
4069         unsafe { ::std::mem::zeroed() }
4070     }
4071 }
4072 #[cfg(feature = "Win32_Foundation")]
4073 impl ::std::fmt::Debug for DHCP_POL_COND {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4074     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4075         fmt.debug_struct("DHCP_POL_COND")
4076             .field("ParentExpr", &self.ParentExpr)
4077             .field("Type", &self.Type)
4078             .field("OptionID", &self.OptionID)
4079             .field("SubOptionID", &self.SubOptionID)
4080             .field("VendorName", &self.VendorName)
4081             .field("Operator", &self.Operator)
4082             .field("Value", &self.Value)
4083             .field("ValueLength", &self.ValueLength)
4084             .finish()
4085     }
4086 }
4087 #[cfg(feature = "Win32_Foundation")]
4088 impl ::std::cmp::PartialEq for DHCP_POL_COND {
eq(&self, other: &Self) -> bool4089     fn eq(&self, other: &Self) -> bool {
4090         self.ParentExpr == other.ParentExpr && self.Type == other.Type && self.OptionID == other.OptionID && self.SubOptionID == other.SubOptionID && self.VendorName == other.VendorName && self.Operator == other.Operator && self.Value == other.Value && self.ValueLength == other.ValueLength
4091     }
4092 }
4093 #[cfg(feature = "Win32_Foundation")]
4094 impl ::std::cmp::Eq for DHCP_POL_COND {}
4095 #[cfg(feature = "Win32_Foundation")]
4096 unsafe impl ::windows::runtime::Abi for DHCP_POL_COND {
4097     type Abi = Self;
4098     type DefaultType = Self;
4099 }
4100 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4101 #[repr(C)]
4102 #[cfg(feature = "Win32_Foundation")]
4103 pub struct DHCP_POL_COND_ARRAY {
4104     pub NumElements: u32,
4105     pub Elements: *mut DHCP_POL_COND,
4106 }
4107 #[cfg(feature = "Win32_Foundation")]
4108 impl DHCP_POL_COND_ARRAY {}
4109 #[cfg(feature = "Win32_Foundation")]
4110 impl ::std::default::Default for DHCP_POL_COND_ARRAY {
default() -> Self4111     fn default() -> Self {
4112         unsafe { ::std::mem::zeroed() }
4113     }
4114 }
4115 #[cfg(feature = "Win32_Foundation")]
4116 impl ::std::fmt::Debug for DHCP_POL_COND_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4117     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4118         fmt.debug_struct("DHCP_POL_COND_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4119     }
4120 }
4121 #[cfg(feature = "Win32_Foundation")]
4122 impl ::std::cmp::PartialEq for DHCP_POL_COND_ARRAY {
eq(&self, other: &Self) -> bool4123     fn eq(&self, other: &Self) -> bool {
4124         self.NumElements == other.NumElements && self.Elements == other.Elements
4125     }
4126 }
4127 #[cfg(feature = "Win32_Foundation")]
4128 impl ::std::cmp::Eq for DHCP_POL_COND_ARRAY {}
4129 #[cfg(feature = "Win32_Foundation")]
4130 unsafe impl ::windows::runtime::Abi for DHCP_POL_COND_ARRAY {
4131     type Abi = Self;
4132     type DefaultType = Self;
4133 }
4134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4135 #[repr(C)]
4136 pub struct DHCP_POL_EXPR {
4137     pub ParentExpr: u32,
4138     pub Operator: DHCP_POL_LOGIC_OPER,
4139 }
4140 impl DHCP_POL_EXPR {}
4141 impl ::std::default::Default for DHCP_POL_EXPR {
default() -> Self4142     fn default() -> Self {
4143         unsafe { ::std::mem::zeroed() }
4144     }
4145 }
4146 impl ::std::fmt::Debug for DHCP_POL_EXPR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4147     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4148         fmt.debug_struct("DHCP_POL_EXPR").field("ParentExpr", &self.ParentExpr).field("Operator", &self.Operator).finish()
4149     }
4150 }
4151 impl ::std::cmp::PartialEq for DHCP_POL_EXPR {
eq(&self, other: &Self) -> bool4152     fn eq(&self, other: &Self) -> bool {
4153         self.ParentExpr == other.ParentExpr && self.Operator == other.Operator
4154     }
4155 }
4156 impl ::std::cmp::Eq for DHCP_POL_EXPR {}
4157 unsafe impl ::windows::runtime::Abi for DHCP_POL_EXPR {
4158     type Abi = Self;
4159     type DefaultType = Self;
4160 }
4161 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4162 #[repr(C)]
4163 pub struct DHCP_POL_EXPR_ARRAY {
4164     pub NumElements: u32,
4165     pub Elements: *mut DHCP_POL_EXPR,
4166 }
4167 impl DHCP_POL_EXPR_ARRAY {}
4168 impl ::std::default::Default for DHCP_POL_EXPR_ARRAY {
default() -> Self4169     fn default() -> Self {
4170         unsafe { ::std::mem::zeroed() }
4171     }
4172 }
4173 impl ::std::fmt::Debug for DHCP_POL_EXPR_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4174     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4175         fmt.debug_struct("DHCP_POL_EXPR_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4176     }
4177 }
4178 impl ::std::cmp::PartialEq for DHCP_POL_EXPR_ARRAY {
eq(&self, other: &Self) -> bool4179     fn eq(&self, other: &Self) -> bool {
4180         self.NumElements == other.NumElements && self.Elements == other.Elements
4181     }
4182 }
4183 impl ::std::cmp::Eq for DHCP_POL_EXPR_ARRAY {}
4184 unsafe impl ::windows::runtime::Abi for DHCP_POL_EXPR_ARRAY {
4185     type Abi = Self;
4186     type DefaultType = Self;
4187 }
4188 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4189 #[repr(transparent)]
4190 pub struct DHCP_POL_LOGIC_OPER(pub i32);
4191 pub const DhcpLogicalOr: DHCP_POL_LOGIC_OPER = DHCP_POL_LOGIC_OPER(0i32);
4192 pub const DhcpLogicalAnd: DHCP_POL_LOGIC_OPER = DHCP_POL_LOGIC_OPER(1i32);
4193 impl ::std::convert::From<i32> for DHCP_POL_LOGIC_OPER {
from(value: i32) -> Self4194     fn from(value: i32) -> Self {
4195         Self(value)
4196     }
4197 }
4198 unsafe impl ::windows::runtime::Abi for DHCP_POL_LOGIC_OPER {
4199     type Abi = Self;
4200     type DefaultType = Self;
4201 }
4202 pub const DHCP_PROB_CONFLICT: u32 = 536870913u32;
4203 pub const DHCP_PROB_DECLINE: u32 = 536870914u32;
4204 pub const DHCP_PROB_NACKED: u32 = 536870916u32;
4205 pub const DHCP_PROB_RELEASE: u32 = 536870915u32;
4206 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4207 #[repr(C)]
4208 #[cfg(feature = "Win32_Foundation")]
4209 pub struct DHCP_PROPERTY {
4210     pub ID: DHCP_PROPERTY_ID,
4211     pub Type: DHCP_PROPERTY_TYPE,
4212     pub Value: DHCP_PROPERTY_0,
4213 }
4214 #[cfg(feature = "Win32_Foundation")]
4215 impl DHCP_PROPERTY {}
4216 #[cfg(feature = "Win32_Foundation")]
4217 impl ::std::default::Default for DHCP_PROPERTY {
default() -> Self4218     fn default() -> Self {
4219         unsafe { ::std::mem::zeroed() }
4220     }
4221 }
4222 #[cfg(feature = "Win32_Foundation")]
4223 impl ::std::cmp::PartialEq for DHCP_PROPERTY {
eq(&self, _other: &Self) -> bool4224     fn eq(&self, _other: &Self) -> bool {
4225         unimplemented!()
4226     }
4227 }
4228 #[cfg(feature = "Win32_Foundation")]
4229 impl ::std::cmp::Eq for DHCP_PROPERTY {}
4230 #[cfg(feature = "Win32_Foundation")]
4231 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY {
4232     type Abi = Self;
4233     type DefaultType = Self;
4234 }
4235 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4236 #[repr(C)]
4237 #[cfg(feature = "Win32_Foundation")]
4238 pub union DHCP_PROPERTY_0 {
4239     pub ByteValue: u8,
4240     pub WordValue: u16,
4241     pub DWordValue: u32,
4242     pub StringValue: super::super::Foundation::PWSTR,
4243     pub BinaryValue: DHCP_BINARY_DATA,
4244 }
4245 #[cfg(feature = "Win32_Foundation")]
4246 impl DHCP_PROPERTY_0 {}
4247 #[cfg(feature = "Win32_Foundation")]
4248 impl ::std::default::Default for DHCP_PROPERTY_0 {
default() -> Self4249     fn default() -> Self {
4250         unsafe { ::std::mem::zeroed() }
4251     }
4252 }
4253 #[cfg(feature = "Win32_Foundation")]
4254 impl ::std::cmp::PartialEq for DHCP_PROPERTY_0 {
eq(&self, _other: &Self) -> bool4255     fn eq(&self, _other: &Self) -> bool {
4256         unimplemented!()
4257     }
4258 }
4259 #[cfg(feature = "Win32_Foundation")]
4260 impl ::std::cmp::Eq for DHCP_PROPERTY_0 {}
4261 #[cfg(feature = "Win32_Foundation")]
4262 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_0 {
4263     type Abi = Self;
4264     type DefaultType = Self;
4265 }
4266 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4267 #[repr(C)]
4268 #[cfg(feature = "Win32_Foundation")]
4269 pub struct DHCP_PROPERTY_ARRAY {
4270     pub NumElements: u32,
4271     pub Elements: *mut DHCP_PROPERTY,
4272 }
4273 #[cfg(feature = "Win32_Foundation")]
4274 impl DHCP_PROPERTY_ARRAY {}
4275 #[cfg(feature = "Win32_Foundation")]
4276 impl ::std::default::Default for DHCP_PROPERTY_ARRAY {
default() -> Self4277     fn default() -> Self {
4278         unsafe { ::std::mem::zeroed() }
4279     }
4280 }
4281 #[cfg(feature = "Win32_Foundation")]
4282 impl ::std::fmt::Debug for DHCP_PROPERTY_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4283     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4284         fmt.debug_struct("DHCP_PROPERTY_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4285     }
4286 }
4287 #[cfg(feature = "Win32_Foundation")]
4288 impl ::std::cmp::PartialEq for DHCP_PROPERTY_ARRAY {
eq(&self, other: &Self) -> bool4289     fn eq(&self, other: &Self) -> bool {
4290         self.NumElements == other.NumElements && self.Elements == other.Elements
4291     }
4292 }
4293 #[cfg(feature = "Win32_Foundation")]
4294 impl ::std::cmp::Eq for DHCP_PROPERTY_ARRAY {}
4295 #[cfg(feature = "Win32_Foundation")]
4296 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_ARRAY {
4297     type Abi = Self;
4298     type DefaultType = Self;
4299 }
4300 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4301 #[repr(transparent)]
4302 pub struct DHCP_PROPERTY_ID(pub i32);
4303 pub const DhcpPropIdPolicyDnsSuffix: DHCP_PROPERTY_ID = DHCP_PROPERTY_ID(0i32);
4304 pub const DhcpPropIdClientAddressStateEx: DHCP_PROPERTY_ID = DHCP_PROPERTY_ID(1i32);
4305 impl ::std::convert::From<i32> for DHCP_PROPERTY_ID {
from(value: i32) -> Self4306     fn from(value: i32) -> Self {
4307         Self(value)
4308     }
4309 }
4310 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_ID {
4311     type Abi = Self;
4312     type DefaultType = Self;
4313 }
4314 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4315 #[repr(transparent)]
4316 pub struct DHCP_PROPERTY_TYPE(pub i32);
4317 pub const DhcpPropTypeByte: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(0i32);
4318 pub const DhcpPropTypeWord: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(1i32);
4319 pub const DhcpPropTypeDword: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(2i32);
4320 pub const DhcpPropTypeString: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(3i32);
4321 pub const DhcpPropTypeBinary: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(4i32);
4322 impl ::std::convert::From<i32> for DHCP_PROPERTY_TYPE {
from(value: i32) -> Self4323     fn from(value: i32) -> Self {
4324         Self(value)
4325     }
4326 }
4327 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_TYPE {
4328     type Abi = Self;
4329     type DefaultType = Self;
4330 }
4331 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4332 #[repr(C)]
4333 #[cfg(feature = "Win32_Foundation")]
4334 pub struct DHCP_RESERVATION_INFO_ARRAY {
4335     pub NumElements: u32,
4336     pub Elements: *mut *mut DHCP_IP_RESERVATION_INFO,
4337 }
4338 #[cfg(feature = "Win32_Foundation")]
4339 impl DHCP_RESERVATION_INFO_ARRAY {}
4340 #[cfg(feature = "Win32_Foundation")]
4341 impl ::std::default::Default for DHCP_RESERVATION_INFO_ARRAY {
default() -> Self4342     fn default() -> Self {
4343         unsafe { ::std::mem::zeroed() }
4344     }
4345 }
4346 #[cfg(feature = "Win32_Foundation")]
4347 impl ::std::fmt::Debug for DHCP_RESERVATION_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4348     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4349         fmt.debug_struct("DHCP_RESERVATION_INFO_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4350     }
4351 }
4352 #[cfg(feature = "Win32_Foundation")]
4353 impl ::std::cmp::PartialEq for DHCP_RESERVATION_INFO_ARRAY {
eq(&self, other: &Self) -> bool4354     fn eq(&self, other: &Self) -> bool {
4355         self.NumElements == other.NumElements && self.Elements == other.Elements
4356     }
4357 }
4358 #[cfg(feature = "Win32_Foundation")]
4359 impl ::std::cmp::Eq for DHCP_RESERVATION_INFO_ARRAY {}
4360 #[cfg(feature = "Win32_Foundation")]
4361 unsafe impl ::windows::runtime::Abi for DHCP_RESERVATION_INFO_ARRAY {
4362     type Abi = Self;
4363     type DefaultType = Self;
4364 }
4365 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4366 #[repr(C)]
4367 pub struct DHCP_RESERVED_SCOPE {
4368     pub ReservedIpAddress: u32,
4369     pub ReservedIpSubnetAddress: u32,
4370 }
4371 impl DHCP_RESERVED_SCOPE {}
4372 impl ::std::default::Default for DHCP_RESERVED_SCOPE {
default() -> Self4373     fn default() -> Self {
4374         unsafe { ::std::mem::zeroed() }
4375     }
4376 }
4377 impl ::std::fmt::Debug for DHCP_RESERVED_SCOPE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4378     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4379         fmt.debug_struct("DHCP_RESERVED_SCOPE").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedIpSubnetAddress", &self.ReservedIpSubnetAddress).finish()
4380     }
4381 }
4382 impl ::std::cmp::PartialEq for DHCP_RESERVED_SCOPE {
eq(&self, other: &Self) -> bool4383     fn eq(&self, other: &Self) -> bool {
4384         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedIpSubnetAddress == other.ReservedIpSubnetAddress
4385     }
4386 }
4387 impl ::std::cmp::Eq for DHCP_RESERVED_SCOPE {}
4388 unsafe impl ::windows::runtime::Abi for DHCP_RESERVED_SCOPE {
4389     type Abi = Self;
4390     type DefaultType = Self;
4391 }
4392 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4393 #[repr(C)]
4394 pub struct DHCP_RESERVED_SCOPE6 {
4395     pub ReservedIpAddress: DHCP_IPV6_ADDRESS,
4396     pub ReservedIpSubnetAddress: DHCP_IPV6_ADDRESS,
4397 }
4398 impl DHCP_RESERVED_SCOPE6 {}
4399 impl ::std::default::Default for DHCP_RESERVED_SCOPE6 {
default() -> Self4400     fn default() -> Self {
4401         unsafe { ::std::mem::zeroed() }
4402     }
4403 }
4404 impl ::std::fmt::Debug for DHCP_RESERVED_SCOPE6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4405     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4406         fmt.debug_struct("DHCP_RESERVED_SCOPE6").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedIpSubnetAddress", &self.ReservedIpSubnetAddress).finish()
4407     }
4408 }
4409 impl ::std::cmp::PartialEq for DHCP_RESERVED_SCOPE6 {
eq(&self, other: &Self) -> bool4410     fn eq(&self, other: &Self) -> bool {
4411         self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedIpSubnetAddress == other.ReservedIpSubnetAddress
4412     }
4413 }
4414 impl ::std::cmp::Eq for DHCP_RESERVED_SCOPE6 {}
4415 unsafe impl ::windows::runtime::Abi for DHCP_RESERVED_SCOPE6 {
4416     type Abi = Self;
4417     type DefaultType = Self;
4418 }
4419 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4420 #[repr(transparent)]
4421 pub struct DHCP_SCAN_FLAG(pub i32);
4422 pub const DhcpRegistryFix: DHCP_SCAN_FLAG = DHCP_SCAN_FLAG(0i32);
4423 pub const DhcpDatabaseFix: DHCP_SCAN_FLAG = DHCP_SCAN_FLAG(1i32);
4424 impl ::std::convert::From<i32> for DHCP_SCAN_FLAG {
from(value: i32) -> Self4425     fn from(value: i32) -> Self {
4426         Self(value)
4427     }
4428 }
4429 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_FLAG {
4430     type Abi = Self;
4431     type DefaultType = Self;
4432 }
4433 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4434 #[repr(C)]
4435 pub struct DHCP_SCAN_ITEM {
4436     pub IpAddress: u32,
4437     pub ScanFlag: DHCP_SCAN_FLAG,
4438 }
4439 impl DHCP_SCAN_ITEM {}
4440 impl ::std::default::Default for DHCP_SCAN_ITEM {
default() -> Self4441     fn default() -> Self {
4442         unsafe { ::std::mem::zeroed() }
4443     }
4444 }
4445 impl ::std::fmt::Debug for DHCP_SCAN_ITEM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4446     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4447         fmt.debug_struct("DHCP_SCAN_ITEM").field("IpAddress", &self.IpAddress).field("ScanFlag", &self.ScanFlag).finish()
4448     }
4449 }
4450 impl ::std::cmp::PartialEq for DHCP_SCAN_ITEM {
eq(&self, other: &Self) -> bool4451     fn eq(&self, other: &Self) -> bool {
4452         self.IpAddress == other.IpAddress && self.ScanFlag == other.ScanFlag
4453     }
4454 }
4455 impl ::std::cmp::Eq for DHCP_SCAN_ITEM {}
4456 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_ITEM {
4457     type Abi = Self;
4458     type DefaultType = Self;
4459 }
4460 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4461 #[repr(C)]
4462 pub struct DHCP_SCAN_LIST {
4463     pub NumScanItems: u32,
4464     pub ScanItems: *mut DHCP_SCAN_ITEM,
4465 }
4466 impl DHCP_SCAN_LIST {}
4467 impl ::std::default::Default for DHCP_SCAN_LIST {
default() -> Self4468     fn default() -> Self {
4469         unsafe { ::std::mem::zeroed() }
4470     }
4471 }
4472 impl ::std::fmt::Debug for DHCP_SCAN_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4473     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4474         fmt.debug_struct("DHCP_SCAN_LIST").field("NumScanItems", &self.NumScanItems).field("ScanItems", &self.ScanItems).finish()
4475     }
4476 }
4477 impl ::std::cmp::PartialEq for DHCP_SCAN_LIST {
eq(&self, other: &Self) -> bool4478     fn eq(&self, other: &Self) -> bool {
4479         self.NumScanItems == other.NumScanItems && self.ScanItems == other.ScanItems
4480     }
4481 }
4482 impl ::std::cmp::Eq for DHCP_SCAN_LIST {}
4483 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_LIST {
4484     type Abi = Self;
4485     type DefaultType = Self;
4486 }
4487 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4488 #[repr(C)]
4489 #[cfg(feature = "Win32_Foundation")]
4490 pub struct DHCP_SEARCH_INFO {
4491     pub SearchType: DHCP_SEARCH_INFO_TYPE,
4492     pub SearchInfo: DHCP_SEARCH_INFO_0,
4493 }
4494 #[cfg(feature = "Win32_Foundation")]
4495 impl DHCP_SEARCH_INFO {}
4496 #[cfg(feature = "Win32_Foundation")]
4497 impl ::std::default::Default for DHCP_SEARCH_INFO {
default() -> Self4498     fn default() -> Self {
4499         unsafe { ::std::mem::zeroed() }
4500     }
4501 }
4502 #[cfg(feature = "Win32_Foundation")]
4503 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO {
eq(&self, _other: &Self) -> bool4504     fn eq(&self, _other: &Self) -> bool {
4505         unimplemented!()
4506     }
4507 }
4508 #[cfg(feature = "Win32_Foundation")]
4509 impl ::std::cmp::Eq for DHCP_SEARCH_INFO {}
4510 #[cfg(feature = "Win32_Foundation")]
4511 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO {
4512     type Abi = Self;
4513     type DefaultType = Self;
4514 }
4515 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4516 #[repr(C)]
4517 #[cfg(feature = "Win32_Foundation")]
4518 pub union DHCP_SEARCH_INFO_0 {
4519     pub ClientIpAddress: u32,
4520     pub ClientHardwareAddress: DHCP_BINARY_DATA,
4521     pub ClientName: super::super::Foundation::PWSTR,
4522 }
4523 #[cfg(feature = "Win32_Foundation")]
4524 impl DHCP_SEARCH_INFO_0 {}
4525 #[cfg(feature = "Win32_Foundation")]
4526 impl ::std::default::Default for DHCP_SEARCH_INFO_0 {
default() -> Self4527     fn default() -> Self {
4528         unsafe { ::std::mem::zeroed() }
4529     }
4530 }
4531 #[cfg(feature = "Win32_Foundation")]
4532 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_0 {
eq(&self, _other: &Self) -> bool4533     fn eq(&self, _other: &Self) -> bool {
4534         unimplemented!()
4535     }
4536 }
4537 #[cfg(feature = "Win32_Foundation")]
4538 impl ::std::cmp::Eq for DHCP_SEARCH_INFO_0 {}
4539 #[cfg(feature = "Win32_Foundation")]
4540 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_0 {
4541     type Abi = Self;
4542     type DefaultType = Self;
4543 }
4544 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4545 #[repr(transparent)]
4546 pub struct DHCP_SEARCH_INFO_TYPE(pub i32);
4547 pub const DhcpClientIpAddress: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(0i32);
4548 pub const DhcpClientHardwareAddress: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(1i32);
4549 pub const DhcpClientName: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(2i32);
4550 impl ::std::convert::From<i32> for DHCP_SEARCH_INFO_TYPE {
from(value: i32) -> Self4551     fn from(value: i32) -> Self {
4552         Self(value)
4553     }
4554 }
4555 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_TYPE {
4556     type Abi = Self;
4557     type DefaultType = Self;
4558 }
4559 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4560 #[repr(transparent)]
4561 pub struct DHCP_SEARCH_INFO_TYPE_V6(pub i32);
4562 pub const Dhcpv6ClientIpAddress: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(0i32);
4563 pub const Dhcpv6ClientDUID: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(1i32);
4564 pub const Dhcpv6ClientName: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(2i32);
4565 impl ::std::convert::From<i32> for DHCP_SEARCH_INFO_TYPE_V6 {
from(value: i32) -> Self4566     fn from(value: i32) -> Self {
4567         Self(value)
4568     }
4569 }
4570 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_TYPE_V6 {
4571     type Abi = Self;
4572     type DefaultType = Self;
4573 }
4574 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4575 #[repr(C)]
4576 #[cfg(feature = "Win32_Foundation")]
4577 pub struct DHCP_SEARCH_INFO_V6 {
4578     pub SearchType: DHCP_SEARCH_INFO_TYPE_V6,
4579     pub SearchInfo: DHCP_SEARCH_INFO_V6_0,
4580 }
4581 #[cfg(feature = "Win32_Foundation")]
4582 impl DHCP_SEARCH_INFO_V6 {}
4583 #[cfg(feature = "Win32_Foundation")]
4584 impl ::std::default::Default for DHCP_SEARCH_INFO_V6 {
default() -> Self4585     fn default() -> Self {
4586         unsafe { ::std::mem::zeroed() }
4587     }
4588 }
4589 #[cfg(feature = "Win32_Foundation")]
4590 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_V6 {
eq(&self, _other: &Self) -> bool4591     fn eq(&self, _other: &Self) -> bool {
4592         unimplemented!()
4593     }
4594 }
4595 #[cfg(feature = "Win32_Foundation")]
4596 impl ::std::cmp::Eq for DHCP_SEARCH_INFO_V6 {}
4597 #[cfg(feature = "Win32_Foundation")]
4598 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_V6 {
4599     type Abi = Self;
4600     type DefaultType = Self;
4601 }
4602 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4603 #[repr(C)]
4604 #[cfg(feature = "Win32_Foundation")]
4605 pub union DHCP_SEARCH_INFO_V6_0 {
4606     pub ClientIpAddress: DHCP_IPV6_ADDRESS,
4607     pub ClientDUID: DHCP_BINARY_DATA,
4608     pub ClientName: super::super::Foundation::PWSTR,
4609 }
4610 #[cfg(feature = "Win32_Foundation")]
4611 impl DHCP_SEARCH_INFO_V6_0 {}
4612 #[cfg(feature = "Win32_Foundation")]
4613 impl ::std::default::Default for DHCP_SEARCH_INFO_V6_0 {
default() -> Self4614     fn default() -> Self {
4615         unsafe { ::std::mem::zeroed() }
4616     }
4617 }
4618 #[cfg(feature = "Win32_Foundation")]
4619 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_V6_0 {
eq(&self, _other: &Self) -> bool4620     fn eq(&self, _other: &Self) -> bool {
4621         unimplemented!()
4622     }
4623 }
4624 #[cfg(feature = "Win32_Foundation")]
4625 impl ::std::cmp::Eq for DHCP_SEARCH_INFO_V6_0 {}
4626 #[cfg(feature = "Win32_Foundation")]
4627 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_V6_0 {
4628     type Abi = Self;
4629     type DefaultType = Self;
4630 }
4631 pub const DHCP_SEND_PACKET: u32 = 268435456u32;
4632 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4633 #[repr(C)]
4634 #[cfg(feature = "Win32_Foundation")]
4635 pub struct DHCP_SERVER_CONFIG_INFO {
4636     pub APIProtocolSupport: u32,
4637     pub DatabaseName: super::super::Foundation::PWSTR,
4638     pub DatabasePath: super::super::Foundation::PWSTR,
4639     pub BackupPath: super::super::Foundation::PWSTR,
4640     pub BackupInterval: u32,
4641     pub DatabaseLoggingFlag: u32,
4642     pub RestoreFlag: u32,
4643     pub DatabaseCleanupInterval: u32,
4644     pub DebugFlag: u32,
4645 }
4646 #[cfg(feature = "Win32_Foundation")]
4647 impl DHCP_SERVER_CONFIG_INFO {}
4648 #[cfg(feature = "Win32_Foundation")]
4649 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO {
default() -> Self4650     fn default() -> Self {
4651         unsafe { ::std::mem::zeroed() }
4652     }
4653 }
4654 #[cfg(feature = "Win32_Foundation")]
4655 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4656     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4657         fmt.debug_struct("DHCP_SERVER_CONFIG_INFO")
4658             .field("APIProtocolSupport", &self.APIProtocolSupport)
4659             .field("DatabaseName", &self.DatabaseName)
4660             .field("DatabasePath", &self.DatabasePath)
4661             .field("BackupPath", &self.BackupPath)
4662             .field("BackupInterval", &self.BackupInterval)
4663             .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4664             .field("RestoreFlag", &self.RestoreFlag)
4665             .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4666             .field("DebugFlag", &self.DebugFlag)
4667             .finish()
4668     }
4669 }
4670 #[cfg(feature = "Win32_Foundation")]
4671 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO {
eq(&self, other: &Self) -> bool4672     fn eq(&self, other: &Self) -> bool {
4673         self.APIProtocolSupport == other.APIProtocolSupport && self.DatabaseName == other.DatabaseName && self.DatabasePath == other.DatabasePath && self.BackupPath == other.BackupPath && self.BackupInterval == other.BackupInterval && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag && self.RestoreFlag == other.RestoreFlag && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval && self.DebugFlag == other.DebugFlag
4674     }
4675 }
4676 #[cfg(feature = "Win32_Foundation")]
4677 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO {}
4678 #[cfg(feature = "Win32_Foundation")]
4679 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO {
4680     type Abi = Self;
4681     type DefaultType = Self;
4682 }
4683 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4684 #[repr(C)]
4685 #[cfg(feature = "Win32_Foundation")]
4686 pub struct DHCP_SERVER_CONFIG_INFO_V4 {
4687     pub APIProtocolSupport: u32,
4688     pub DatabaseName: super::super::Foundation::PWSTR,
4689     pub DatabasePath: super::super::Foundation::PWSTR,
4690     pub BackupPath: super::super::Foundation::PWSTR,
4691     pub BackupInterval: u32,
4692     pub DatabaseLoggingFlag: u32,
4693     pub RestoreFlag: u32,
4694     pub DatabaseCleanupInterval: u32,
4695     pub DebugFlag: u32,
4696     pub dwPingRetries: u32,
4697     pub cbBootTableString: u32,
4698     pub wszBootTableString: super::super::Foundation::PWSTR,
4699     pub fAuditLog: super::super::Foundation::BOOL,
4700 }
4701 #[cfg(feature = "Win32_Foundation")]
4702 impl DHCP_SERVER_CONFIG_INFO_V4 {}
4703 #[cfg(feature = "Win32_Foundation")]
4704 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_V4 {
default() -> Self4705     fn default() -> Self {
4706         unsafe { ::std::mem::zeroed() }
4707     }
4708 }
4709 #[cfg(feature = "Win32_Foundation")]
4710 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4711     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4712         fmt.debug_struct("DHCP_SERVER_CONFIG_INFO_V4")
4713             .field("APIProtocolSupport", &self.APIProtocolSupport)
4714             .field("DatabaseName", &self.DatabaseName)
4715             .field("DatabasePath", &self.DatabasePath)
4716             .field("BackupPath", &self.BackupPath)
4717             .field("BackupInterval", &self.BackupInterval)
4718             .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4719             .field("RestoreFlag", &self.RestoreFlag)
4720             .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4721             .field("DebugFlag", &self.DebugFlag)
4722             .field("dwPingRetries", &self.dwPingRetries)
4723             .field("cbBootTableString", &self.cbBootTableString)
4724             .field("wszBootTableString", &self.wszBootTableString)
4725             .field("fAuditLog", &self.fAuditLog)
4726             .finish()
4727     }
4728 }
4729 #[cfg(feature = "Win32_Foundation")]
4730 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_V4 {
eq(&self, other: &Self) -> bool4731     fn eq(&self, other: &Self) -> bool {
4732         self.APIProtocolSupport == other.APIProtocolSupport
4733             && self.DatabaseName == other.DatabaseName
4734             && self.DatabasePath == other.DatabasePath
4735             && self.BackupPath == other.BackupPath
4736             && self.BackupInterval == other.BackupInterval
4737             && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag
4738             && self.RestoreFlag == other.RestoreFlag
4739             && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval
4740             && self.DebugFlag == other.DebugFlag
4741             && self.dwPingRetries == other.dwPingRetries
4742             && self.cbBootTableString == other.cbBootTableString
4743             && self.wszBootTableString == other.wszBootTableString
4744             && self.fAuditLog == other.fAuditLog
4745     }
4746 }
4747 #[cfg(feature = "Win32_Foundation")]
4748 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_V4 {}
4749 #[cfg(feature = "Win32_Foundation")]
4750 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_V4 {
4751     type Abi = Self;
4752     type DefaultType = Self;
4753 }
4754 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4755 #[repr(C)]
4756 #[cfg(feature = "Win32_Foundation")]
4757 pub struct DHCP_SERVER_CONFIG_INFO_V6 {
4758     pub UnicastFlag: super::super::Foundation::BOOL,
4759     pub RapidCommitFlag: super::super::Foundation::BOOL,
4760     pub PreferredLifetime: u32,
4761     pub ValidLifetime: u32,
4762     pub T1: u32,
4763     pub T2: u32,
4764     pub PreferredLifetimeIATA: u32,
4765     pub ValidLifetimeIATA: u32,
4766     pub fAuditLog: super::super::Foundation::BOOL,
4767 }
4768 #[cfg(feature = "Win32_Foundation")]
4769 impl DHCP_SERVER_CONFIG_INFO_V6 {}
4770 #[cfg(feature = "Win32_Foundation")]
4771 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_V6 {
default() -> Self4772     fn default() -> Self {
4773         unsafe { ::std::mem::zeroed() }
4774     }
4775 }
4776 #[cfg(feature = "Win32_Foundation")]
4777 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4778     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4779         fmt.debug_struct("DHCP_SERVER_CONFIG_INFO_V6")
4780             .field("UnicastFlag", &self.UnicastFlag)
4781             .field("RapidCommitFlag", &self.RapidCommitFlag)
4782             .field("PreferredLifetime", &self.PreferredLifetime)
4783             .field("ValidLifetime", &self.ValidLifetime)
4784             .field("T1", &self.T1)
4785             .field("T2", &self.T2)
4786             .field("PreferredLifetimeIATA", &self.PreferredLifetimeIATA)
4787             .field("ValidLifetimeIATA", &self.ValidLifetimeIATA)
4788             .field("fAuditLog", &self.fAuditLog)
4789             .finish()
4790     }
4791 }
4792 #[cfg(feature = "Win32_Foundation")]
4793 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_V6 {
eq(&self, other: &Self) -> bool4794     fn eq(&self, other: &Self) -> bool {
4795         self.UnicastFlag == other.UnicastFlag && self.RapidCommitFlag == other.RapidCommitFlag && self.PreferredLifetime == other.PreferredLifetime && self.ValidLifetime == other.ValidLifetime && self.T1 == other.T1 && self.T2 == other.T2 && self.PreferredLifetimeIATA == other.PreferredLifetimeIATA && self.ValidLifetimeIATA == other.ValidLifetimeIATA && self.fAuditLog == other.fAuditLog
4796     }
4797 }
4798 #[cfg(feature = "Win32_Foundation")]
4799 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_V6 {}
4800 #[cfg(feature = "Win32_Foundation")]
4801 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_V6 {
4802     type Abi = Self;
4803     type DefaultType = Self;
4804 }
4805 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4806 #[repr(C)]
4807 #[cfg(feature = "Win32_Foundation")]
4808 pub struct DHCP_SERVER_CONFIG_INFO_VQ {
4809     pub APIProtocolSupport: u32,
4810     pub DatabaseName: super::super::Foundation::PWSTR,
4811     pub DatabasePath: super::super::Foundation::PWSTR,
4812     pub BackupPath: super::super::Foundation::PWSTR,
4813     pub BackupInterval: u32,
4814     pub DatabaseLoggingFlag: u32,
4815     pub RestoreFlag: u32,
4816     pub DatabaseCleanupInterval: u32,
4817     pub DebugFlag: u32,
4818     pub dwPingRetries: u32,
4819     pub cbBootTableString: u32,
4820     pub wszBootTableString: super::super::Foundation::PWSTR,
4821     pub fAuditLog: super::super::Foundation::BOOL,
4822     pub QuarantineOn: super::super::Foundation::BOOL,
4823     pub QuarDefFail: u32,
4824     pub QuarRuntimeStatus: super::super::Foundation::BOOL,
4825 }
4826 #[cfg(feature = "Win32_Foundation")]
4827 impl DHCP_SERVER_CONFIG_INFO_VQ {}
4828 #[cfg(feature = "Win32_Foundation")]
4829 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_VQ {
default() -> Self4830     fn default() -> Self {
4831         unsafe { ::std::mem::zeroed() }
4832     }
4833 }
4834 #[cfg(feature = "Win32_Foundation")]
4835 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4836     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4837         fmt.debug_struct("DHCP_SERVER_CONFIG_INFO_VQ")
4838             .field("APIProtocolSupport", &self.APIProtocolSupport)
4839             .field("DatabaseName", &self.DatabaseName)
4840             .field("DatabasePath", &self.DatabasePath)
4841             .field("BackupPath", &self.BackupPath)
4842             .field("BackupInterval", &self.BackupInterval)
4843             .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4844             .field("RestoreFlag", &self.RestoreFlag)
4845             .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4846             .field("DebugFlag", &self.DebugFlag)
4847             .field("dwPingRetries", &self.dwPingRetries)
4848             .field("cbBootTableString", &self.cbBootTableString)
4849             .field("wszBootTableString", &self.wszBootTableString)
4850             .field("fAuditLog", &self.fAuditLog)
4851             .field("QuarantineOn", &self.QuarantineOn)
4852             .field("QuarDefFail", &self.QuarDefFail)
4853             .field("QuarRuntimeStatus", &self.QuarRuntimeStatus)
4854             .finish()
4855     }
4856 }
4857 #[cfg(feature = "Win32_Foundation")]
4858 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_VQ {
eq(&self, other: &Self) -> bool4859     fn eq(&self, other: &Self) -> bool {
4860         self.APIProtocolSupport == other.APIProtocolSupport
4861             && self.DatabaseName == other.DatabaseName
4862             && self.DatabasePath == other.DatabasePath
4863             && self.BackupPath == other.BackupPath
4864             && self.BackupInterval == other.BackupInterval
4865             && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag
4866             && self.RestoreFlag == other.RestoreFlag
4867             && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval
4868             && self.DebugFlag == other.DebugFlag
4869             && self.dwPingRetries == other.dwPingRetries
4870             && self.cbBootTableString == other.cbBootTableString
4871             && self.wszBootTableString == other.wszBootTableString
4872             && self.fAuditLog == other.fAuditLog
4873             && self.QuarantineOn == other.QuarantineOn
4874             && self.QuarDefFail == other.QuarDefFail
4875             && self.QuarRuntimeStatus == other.QuarRuntimeStatus
4876     }
4877 }
4878 #[cfg(feature = "Win32_Foundation")]
4879 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_VQ {}
4880 #[cfg(feature = "Win32_Foundation")]
4881 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_VQ {
4882     type Abi = Self;
4883     type DefaultType = Self;
4884 }
4885 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4886 #[repr(C)]
4887 #[cfg(feature = "Win32_Foundation")]
4888 pub struct DHCP_SERVER_OPTIONS {
4889     pub MessageType: *mut u8,
4890     pub SubnetMask: *mut u32,
4891     pub RequestedAddress: *mut u32,
4892     pub RequestLeaseTime: *mut u32,
4893     pub OverlayFields: *mut u8,
4894     pub RouterAddress: *mut u32,
4895     pub Server: *mut u32,
4896     pub ParameterRequestList: *mut u8,
4897     pub ParameterRequestListLength: u32,
4898     pub MachineName: super::super::Foundation::PSTR,
4899     pub MachineNameLength: u32,
4900     pub ClientHardwareAddressType: u8,
4901     pub ClientHardwareAddressLength: u8,
4902     pub ClientHardwareAddress: *mut u8,
4903     pub ClassIdentifier: super::super::Foundation::PSTR,
4904     pub ClassIdentifierLength: u32,
4905     pub VendorClass: *mut u8,
4906     pub VendorClassLength: u32,
4907     pub DNSFlags: u32,
4908     pub DNSNameLength: u32,
4909     pub DNSName: *mut u8,
4910     pub DSDomainNameRequested: super::super::Foundation::BOOLEAN,
4911     pub DSDomainName: super::super::Foundation::PSTR,
4912     pub DSDomainNameLen: u32,
4913     pub ScopeId: *mut u32,
4914 }
4915 #[cfg(feature = "Win32_Foundation")]
4916 impl DHCP_SERVER_OPTIONS {}
4917 #[cfg(feature = "Win32_Foundation")]
4918 impl ::std::default::Default for DHCP_SERVER_OPTIONS {
default() -> Self4919     fn default() -> Self {
4920         unsafe { ::std::mem::zeroed() }
4921     }
4922 }
4923 #[cfg(feature = "Win32_Foundation")]
4924 impl ::std::fmt::Debug for DHCP_SERVER_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4925     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4926         fmt.debug_struct("DHCP_SERVER_OPTIONS")
4927             .field("MessageType", &self.MessageType)
4928             .field("SubnetMask", &self.SubnetMask)
4929             .field("RequestedAddress", &self.RequestedAddress)
4930             .field("RequestLeaseTime", &self.RequestLeaseTime)
4931             .field("OverlayFields", &self.OverlayFields)
4932             .field("RouterAddress", &self.RouterAddress)
4933             .field("Server", &self.Server)
4934             .field("ParameterRequestList", &self.ParameterRequestList)
4935             .field("ParameterRequestListLength", &self.ParameterRequestListLength)
4936             .field("MachineName", &self.MachineName)
4937             .field("MachineNameLength", &self.MachineNameLength)
4938             .field("ClientHardwareAddressType", &self.ClientHardwareAddressType)
4939             .field("ClientHardwareAddressLength", &self.ClientHardwareAddressLength)
4940             .field("ClientHardwareAddress", &self.ClientHardwareAddress)
4941             .field("ClassIdentifier", &self.ClassIdentifier)
4942             .field("ClassIdentifierLength", &self.ClassIdentifierLength)
4943             .field("VendorClass", &self.VendorClass)
4944             .field("VendorClassLength", &self.VendorClassLength)
4945             .field("DNSFlags", &self.DNSFlags)
4946             .field("DNSNameLength", &self.DNSNameLength)
4947             .field("DNSName", &self.DNSName)
4948             .field("DSDomainNameRequested", &self.DSDomainNameRequested)
4949             .field("DSDomainName", &self.DSDomainName)
4950             .field("DSDomainNameLen", &self.DSDomainNameLen)
4951             .field("ScopeId", &self.ScopeId)
4952             .finish()
4953     }
4954 }
4955 #[cfg(feature = "Win32_Foundation")]
4956 impl ::std::cmp::PartialEq for DHCP_SERVER_OPTIONS {
eq(&self, other: &Self) -> bool4957     fn eq(&self, other: &Self) -> bool {
4958         self.MessageType == other.MessageType
4959             && self.SubnetMask == other.SubnetMask
4960             && self.RequestedAddress == other.RequestedAddress
4961             && self.RequestLeaseTime == other.RequestLeaseTime
4962             && self.OverlayFields == other.OverlayFields
4963             && self.RouterAddress == other.RouterAddress
4964             && self.Server == other.Server
4965             && self.ParameterRequestList == other.ParameterRequestList
4966             && self.ParameterRequestListLength == other.ParameterRequestListLength
4967             && self.MachineName == other.MachineName
4968             && self.MachineNameLength == other.MachineNameLength
4969             && self.ClientHardwareAddressType == other.ClientHardwareAddressType
4970             && self.ClientHardwareAddressLength == other.ClientHardwareAddressLength
4971             && self.ClientHardwareAddress == other.ClientHardwareAddress
4972             && self.ClassIdentifier == other.ClassIdentifier
4973             && self.ClassIdentifierLength == other.ClassIdentifierLength
4974             && self.VendorClass == other.VendorClass
4975             && self.VendorClassLength == other.VendorClassLength
4976             && self.DNSFlags == other.DNSFlags
4977             && self.DNSNameLength == other.DNSNameLength
4978             && self.DNSName == other.DNSName
4979             && self.DSDomainNameRequested == other.DSDomainNameRequested
4980             && self.DSDomainName == other.DSDomainName
4981             && self.DSDomainNameLen == other.DSDomainNameLen
4982             && self.ScopeId == other.ScopeId
4983     }
4984 }
4985 #[cfg(feature = "Win32_Foundation")]
4986 impl ::std::cmp::Eq for DHCP_SERVER_OPTIONS {}
4987 #[cfg(feature = "Win32_Foundation")]
4988 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_OPTIONS {
4989     type Abi = Self;
4990     type DefaultType = Self;
4991 }
4992 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4993 #[repr(C)]
4994 #[cfg(feature = "Win32_Foundation")]
4995 pub struct DHCP_SERVER_SPECIFIC_STRINGS {
4996     pub DefaultVendorClassName: super::super::Foundation::PWSTR,
4997     pub DefaultUserClassName: super::super::Foundation::PWSTR,
4998 }
4999 #[cfg(feature = "Win32_Foundation")]
5000 impl DHCP_SERVER_SPECIFIC_STRINGS {}
5001 #[cfg(feature = "Win32_Foundation")]
5002 impl ::std::default::Default for DHCP_SERVER_SPECIFIC_STRINGS {
default() -> Self5003     fn default() -> Self {
5004         unsafe { ::std::mem::zeroed() }
5005     }
5006 }
5007 #[cfg(feature = "Win32_Foundation")]
5008 impl ::std::fmt::Debug for DHCP_SERVER_SPECIFIC_STRINGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5009     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5010         fmt.debug_struct("DHCP_SERVER_SPECIFIC_STRINGS").field("DefaultVendorClassName", &self.DefaultVendorClassName).field("DefaultUserClassName", &self.DefaultUserClassName).finish()
5011     }
5012 }
5013 #[cfg(feature = "Win32_Foundation")]
5014 impl ::std::cmp::PartialEq for DHCP_SERVER_SPECIFIC_STRINGS {
eq(&self, other: &Self) -> bool5015     fn eq(&self, other: &Self) -> bool {
5016         self.DefaultVendorClassName == other.DefaultVendorClassName && self.DefaultUserClassName == other.DefaultUserClassName
5017     }
5018 }
5019 #[cfg(feature = "Win32_Foundation")]
5020 impl ::std::cmp::Eq for DHCP_SERVER_SPECIFIC_STRINGS {}
5021 #[cfg(feature = "Win32_Foundation")]
5022 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_SPECIFIC_STRINGS {
5023     type Abi = Self;
5024     type DefaultType = Self;
5025 }
5026 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5027 #[repr(C)]
5028 #[cfg(feature = "Win32_Foundation")]
5029 pub struct DHCP_SUBNET_ELEMENT_DATA {
5030     pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5031     pub Element: DHCP_SUBNET_ELEMENT_DATA_0,
5032 }
5033 #[cfg(feature = "Win32_Foundation")]
5034 impl DHCP_SUBNET_ELEMENT_DATA {}
5035 #[cfg(feature = "Win32_Foundation")]
5036 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA {
default() -> Self5037     fn default() -> Self {
5038         unsafe { ::std::mem::zeroed() }
5039     }
5040 }
5041 #[cfg(feature = "Win32_Foundation")]
5042 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA {
eq(&self, _other: &Self) -> bool5043     fn eq(&self, _other: &Self) -> bool {
5044         unimplemented!()
5045     }
5046 }
5047 #[cfg(feature = "Win32_Foundation")]
5048 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA {}
5049 #[cfg(feature = "Win32_Foundation")]
5050 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA {
5051     type Abi = Self;
5052     type DefaultType = Self;
5053 }
5054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5055 #[repr(C)]
5056 #[cfg(feature = "Win32_Foundation")]
5057 pub union DHCP_SUBNET_ELEMENT_DATA_0 {
5058     pub IpRange: *mut DHCP_IP_RANGE,
5059     pub SecondaryHost: *mut DHCP_HOST_INFO,
5060     pub ReservedIp: *mut DHCP_IP_RESERVATION,
5061     pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5062     pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5063 }
5064 #[cfg(feature = "Win32_Foundation")]
5065 impl DHCP_SUBNET_ELEMENT_DATA_0 {}
5066 #[cfg(feature = "Win32_Foundation")]
5067 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_0 {
default() -> Self5068     fn default() -> Self {
5069         unsafe { ::std::mem::zeroed() }
5070     }
5071 }
5072 #[cfg(feature = "Win32_Foundation")]
5073 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_0 {
eq(&self, _other: &Self) -> bool5074     fn eq(&self, _other: &Self) -> bool {
5075         unimplemented!()
5076     }
5077 }
5078 #[cfg(feature = "Win32_Foundation")]
5079 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_0 {}
5080 #[cfg(feature = "Win32_Foundation")]
5081 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_0 {
5082     type Abi = Self;
5083     type DefaultType = Self;
5084 }
5085 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5086 #[repr(C)]
5087 #[cfg(feature = "Win32_Foundation")]
5088 pub struct DHCP_SUBNET_ELEMENT_DATA_V4 {
5089     pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5090     pub Element: DHCP_SUBNET_ELEMENT_DATA_V4_0,
5091 }
5092 #[cfg(feature = "Win32_Foundation")]
5093 impl DHCP_SUBNET_ELEMENT_DATA_V4 {}
5094 #[cfg(feature = "Win32_Foundation")]
5095 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V4 {
default() -> Self5096     fn default() -> Self {
5097         unsafe { ::std::mem::zeroed() }
5098     }
5099 }
5100 #[cfg(feature = "Win32_Foundation")]
5101 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V4 {
eq(&self, _other: &Self) -> bool5102     fn eq(&self, _other: &Self) -> bool {
5103         unimplemented!()
5104     }
5105 }
5106 #[cfg(feature = "Win32_Foundation")]
5107 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V4 {}
5108 #[cfg(feature = "Win32_Foundation")]
5109 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V4 {
5110     type Abi = Self;
5111     type DefaultType = Self;
5112 }
5113 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5114 #[repr(C)]
5115 #[cfg(feature = "Win32_Foundation")]
5116 pub union DHCP_SUBNET_ELEMENT_DATA_V4_0 {
5117     pub IpRange: *mut DHCP_IP_RANGE,
5118     pub SecondaryHost: *mut DHCP_HOST_INFO,
5119     pub ReservedIp: *mut DHCP_IP_RESERVATION_V4,
5120     pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5121     pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5122 }
5123 #[cfg(feature = "Win32_Foundation")]
5124 impl DHCP_SUBNET_ELEMENT_DATA_V4_0 {}
5125 #[cfg(feature = "Win32_Foundation")]
5126 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
default() -> Self5127     fn default() -> Self {
5128         unsafe { ::std::mem::zeroed() }
5129     }
5130 }
5131 #[cfg(feature = "Win32_Foundation")]
5132 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
eq(&self, _other: &Self) -> bool5133     fn eq(&self, _other: &Self) -> bool {
5134         unimplemented!()
5135     }
5136 }
5137 #[cfg(feature = "Win32_Foundation")]
5138 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V4_0 {}
5139 #[cfg(feature = "Win32_Foundation")]
5140 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
5141     type Abi = Self;
5142     type DefaultType = Self;
5143 }
5144 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5145 #[repr(C)]
5146 #[cfg(feature = "Win32_Foundation")]
5147 pub struct DHCP_SUBNET_ELEMENT_DATA_V5 {
5148     pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5149     pub Element: DHCP_SUBNET_ELEMENT_DATA_V5_0,
5150 }
5151 #[cfg(feature = "Win32_Foundation")]
5152 impl DHCP_SUBNET_ELEMENT_DATA_V5 {}
5153 #[cfg(feature = "Win32_Foundation")]
5154 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V5 {
default() -> Self5155     fn default() -> Self {
5156         unsafe { ::std::mem::zeroed() }
5157     }
5158 }
5159 #[cfg(feature = "Win32_Foundation")]
5160 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V5 {
eq(&self, _other: &Self) -> bool5161     fn eq(&self, _other: &Self) -> bool {
5162         unimplemented!()
5163     }
5164 }
5165 #[cfg(feature = "Win32_Foundation")]
5166 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V5 {}
5167 #[cfg(feature = "Win32_Foundation")]
5168 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V5 {
5169     type Abi = Self;
5170     type DefaultType = Self;
5171 }
5172 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5173 #[repr(C)]
5174 #[cfg(feature = "Win32_Foundation")]
5175 pub union DHCP_SUBNET_ELEMENT_DATA_V5_0 {
5176     pub IpRange: *mut DHCP_BOOTP_IP_RANGE,
5177     pub SecondaryHost: *mut DHCP_HOST_INFO,
5178     pub ReservedIp: *mut DHCP_IP_RESERVATION_V4,
5179     pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5180     pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5181 }
5182 #[cfg(feature = "Win32_Foundation")]
5183 impl DHCP_SUBNET_ELEMENT_DATA_V5_0 {}
5184 #[cfg(feature = "Win32_Foundation")]
5185 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
default() -> Self5186     fn default() -> Self {
5187         unsafe { ::std::mem::zeroed() }
5188     }
5189 }
5190 #[cfg(feature = "Win32_Foundation")]
5191 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
eq(&self, _other: &Self) -> bool5192     fn eq(&self, _other: &Self) -> bool {
5193         unimplemented!()
5194     }
5195 }
5196 #[cfg(feature = "Win32_Foundation")]
5197 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V5_0 {}
5198 #[cfg(feature = "Win32_Foundation")]
5199 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
5200     type Abi = Self;
5201     type DefaultType = Self;
5202 }
5203 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5204 #[repr(C)]
5205 pub struct DHCP_SUBNET_ELEMENT_DATA_V6 {
5206     pub ElementType: DHCP_SUBNET_ELEMENT_TYPE_V6,
5207     pub Element: DHCP_SUBNET_ELEMENT_DATA_V6_0,
5208 }
5209 impl DHCP_SUBNET_ELEMENT_DATA_V6 {}
5210 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V6 {
default() -> Self5211     fn default() -> Self {
5212         unsafe { ::std::mem::zeroed() }
5213     }
5214 }
5215 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V6 {
eq(&self, _other: &Self) -> bool5216     fn eq(&self, _other: &Self) -> bool {
5217         unimplemented!()
5218     }
5219 }
5220 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V6 {}
5221 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V6 {
5222     type Abi = Self;
5223     type DefaultType = Self;
5224 }
5225 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5226 #[repr(C)]
5227 pub union DHCP_SUBNET_ELEMENT_DATA_V6_0 {
5228     pub IpRange: *mut DHCP_IP_RANGE_V6,
5229     pub ReservedIp: *mut DHCP_IP_RESERVATION_V6,
5230     pub ExcludeIpRange: *mut DHCP_IP_RANGE_V6,
5231 }
5232 impl DHCP_SUBNET_ELEMENT_DATA_V6_0 {}
5233 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
default() -> Self5234     fn default() -> Self {
5235         unsafe { ::std::mem::zeroed() }
5236     }
5237 }
5238 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
eq(&self, _other: &Self) -> bool5239     fn eq(&self, _other: &Self) -> bool {
5240         unimplemented!()
5241     }
5242 }
5243 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V6_0 {}
5244 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
5245     type Abi = Self;
5246     type DefaultType = Self;
5247 }
5248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5249 #[repr(C)]
5250 #[cfg(feature = "Win32_Foundation")]
5251 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY {
5252     pub NumElements: u32,
5253     pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA,
5254 }
5255 #[cfg(feature = "Win32_Foundation")]
5256 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY {}
5257 #[cfg(feature = "Win32_Foundation")]
5258 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
default() -> Self5259     fn default() -> Self {
5260         unsafe { ::std::mem::zeroed() }
5261     }
5262 }
5263 #[cfg(feature = "Win32_Foundation")]
5264 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5265     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5266         fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5267     }
5268 }
5269 #[cfg(feature = "Win32_Foundation")]
5270 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool5271     fn eq(&self, other: &Self) -> bool {
5272         self.NumElements == other.NumElements && self.Elements == other.Elements
5273     }
5274 }
5275 #[cfg(feature = "Win32_Foundation")]
5276 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY {}
5277 #[cfg(feature = "Win32_Foundation")]
5278 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
5279     type Abi = Self;
5280     type DefaultType = Self;
5281 }
5282 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5283 #[repr(C)]
5284 #[cfg(feature = "Win32_Foundation")]
5285 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
5286     pub NumElements: u32,
5287     pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V4,
5288 }
5289 #[cfg(feature = "Win32_Foundation")]
5290 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {}
5291 #[cfg(feature = "Win32_Foundation")]
5292 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
default() -> Self5293     fn default() -> Self {
5294         unsafe { ::std::mem::zeroed() }
5295     }
5296 }
5297 #[cfg(feature = "Win32_Foundation")]
5298 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5299     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5300         fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5301     }
5302 }
5303 #[cfg(feature = "Win32_Foundation")]
5304 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
eq(&self, other: &Self) -> bool5305     fn eq(&self, other: &Self) -> bool {
5306         self.NumElements == other.NumElements && self.Elements == other.Elements
5307     }
5308 }
5309 #[cfg(feature = "Win32_Foundation")]
5310 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {}
5311 #[cfg(feature = "Win32_Foundation")]
5312 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
5313     type Abi = Self;
5314     type DefaultType = Self;
5315 }
5316 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5317 #[repr(C)]
5318 #[cfg(feature = "Win32_Foundation")]
5319 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
5320     pub NumElements: u32,
5321     pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V5,
5322 }
5323 #[cfg(feature = "Win32_Foundation")]
5324 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {}
5325 #[cfg(feature = "Win32_Foundation")]
5326 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
default() -> Self5327     fn default() -> Self {
5328         unsafe { ::std::mem::zeroed() }
5329     }
5330 }
5331 #[cfg(feature = "Win32_Foundation")]
5332 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5333     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5334         fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5335     }
5336 }
5337 #[cfg(feature = "Win32_Foundation")]
5338 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
eq(&self, other: &Self) -> bool5339     fn eq(&self, other: &Self) -> bool {
5340         self.NumElements == other.NumElements && self.Elements == other.Elements
5341     }
5342 }
5343 #[cfg(feature = "Win32_Foundation")]
5344 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {}
5345 #[cfg(feature = "Win32_Foundation")]
5346 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
5347     type Abi = Self;
5348     type DefaultType = Self;
5349 }
5350 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5351 #[repr(C)]
5352 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
5353     pub NumElements: u32,
5354     pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V6,
5355 }
5356 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {}
5357 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
default() -> Self5358     fn default() -> Self {
5359         unsafe { ::std::mem::zeroed() }
5360     }
5361 }
5362 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5363     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5364         fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5365     }
5366 }
5367 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool5368     fn eq(&self, other: &Self) -> bool {
5369         self.NumElements == other.NumElements && self.Elements == other.Elements
5370     }
5371 }
5372 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {}
5373 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
5374     type Abi = Self;
5375     type DefaultType = Self;
5376 }
5377 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5378 #[repr(transparent)]
5379 pub struct DHCP_SUBNET_ELEMENT_TYPE(pub i32);
5380 pub const DhcpIpRanges: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(0i32);
5381 pub const DhcpSecondaryHosts: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(1i32);
5382 pub const DhcpReservedIps: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(2i32);
5383 pub const DhcpExcludedIpRanges: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(3i32);
5384 pub const DhcpIpUsedClusters: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(4i32);
5385 pub const DhcpIpRangesDhcpOnly: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(5i32);
5386 pub const DhcpIpRangesDhcpBootp: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(6i32);
5387 pub const DhcpIpRangesBootpOnly: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(7i32);
5388 impl ::std::convert::From<i32> for DHCP_SUBNET_ELEMENT_TYPE {
from(value: i32) -> Self5389     fn from(value: i32) -> Self {
5390         Self(value)
5391     }
5392 }
5393 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_TYPE {
5394     type Abi = Self;
5395     type DefaultType = Self;
5396 }
5397 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5398 #[repr(transparent)]
5399 pub struct DHCP_SUBNET_ELEMENT_TYPE_V6(pub i32);
5400 pub const Dhcpv6IpRanges: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(0i32);
5401 pub const Dhcpv6ReservedIps: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(1i32);
5402 pub const Dhcpv6ExcludedIpRanges: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(2i32);
5403 impl ::std::convert::From<i32> for DHCP_SUBNET_ELEMENT_TYPE_V6 {
from(value: i32) -> Self5404     fn from(value: i32) -> Self {
5405         Self(value)
5406     }
5407 }
5408 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_TYPE_V6 {
5409     type Abi = Self;
5410     type DefaultType = Self;
5411 }
5412 #[repr(C)]
5413 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5414 pub struct DHCP_SUBNET_ELEMENT_UNION(pub u8);
5415 #[repr(C)]
5416 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5417 pub struct DHCP_SUBNET_ELEMENT_UNION_V4(pub u8);
5418 #[repr(C)]
5419 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5420 pub struct DHCP_SUBNET_ELEMENT_UNION_V6(pub u8);
5421 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5422 #[repr(C)]
5423 #[cfg(feature = "Win32_Foundation")]
5424 pub struct DHCP_SUBNET_INFO {
5425     pub SubnetAddress: u32,
5426     pub SubnetMask: u32,
5427     pub SubnetName: super::super::Foundation::PWSTR,
5428     pub SubnetComment: super::super::Foundation::PWSTR,
5429     pub PrimaryHost: DHCP_HOST_INFO,
5430     pub SubnetState: DHCP_SUBNET_STATE,
5431 }
5432 #[cfg(feature = "Win32_Foundation")]
5433 impl DHCP_SUBNET_INFO {}
5434 #[cfg(feature = "Win32_Foundation")]
5435 impl ::std::default::Default for DHCP_SUBNET_INFO {
default() -> Self5436     fn default() -> Self {
5437         unsafe { ::std::mem::zeroed() }
5438     }
5439 }
5440 #[cfg(feature = "Win32_Foundation")]
5441 impl ::std::fmt::Debug for DHCP_SUBNET_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5442     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5443         fmt.debug_struct("DHCP_SUBNET_INFO").field("SubnetAddress", &self.SubnetAddress).field("SubnetMask", &self.SubnetMask).field("SubnetName", &self.SubnetName).field("SubnetComment", &self.SubnetComment).field("PrimaryHost", &self.PrimaryHost).field("SubnetState", &self.SubnetState).finish()
5444     }
5445 }
5446 #[cfg(feature = "Win32_Foundation")]
5447 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO {
eq(&self, other: &Self) -> bool5448     fn eq(&self, other: &Self) -> bool {
5449         self.SubnetAddress == other.SubnetAddress && self.SubnetMask == other.SubnetMask && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.PrimaryHost == other.PrimaryHost && self.SubnetState == other.SubnetState
5450     }
5451 }
5452 #[cfg(feature = "Win32_Foundation")]
5453 impl ::std::cmp::Eq for DHCP_SUBNET_INFO {}
5454 #[cfg(feature = "Win32_Foundation")]
5455 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO {
5456     type Abi = Self;
5457     type DefaultType = Self;
5458 }
5459 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5460 #[repr(C)]
5461 #[cfg(feature = "Win32_Foundation")]
5462 pub struct DHCP_SUBNET_INFO_V6 {
5463     pub SubnetAddress: DHCP_IPV6_ADDRESS,
5464     pub Prefix: u32,
5465     pub Preference: u16,
5466     pub SubnetName: super::super::Foundation::PWSTR,
5467     pub SubnetComment: super::super::Foundation::PWSTR,
5468     pub State: u32,
5469     pub ScopeId: u32,
5470 }
5471 #[cfg(feature = "Win32_Foundation")]
5472 impl DHCP_SUBNET_INFO_V6 {}
5473 #[cfg(feature = "Win32_Foundation")]
5474 impl ::std::default::Default for DHCP_SUBNET_INFO_V6 {
default() -> Self5475     fn default() -> Self {
5476         unsafe { ::std::mem::zeroed() }
5477     }
5478 }
5479 #[cfg(feature = "Win32_Foundation")]
5480 impl ::std::fmt::Debug for DHCP_SUBNET_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5481     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5482         fmt.debug_struct("DHCP_SUBNET_INFO_V6")
5483             .field("SubnetAddress", &self.SubnetAddress)
5484             .field("Prefix", &self.Prefix)
5485             .field("Preference", &self.Preference)
5486             .field("SubnetName", &self.SubnetName)
5487             .field("SubnetComment", &self.SubnetComment)
5488             .field("State", &self.State)
5489             .field("ScopeId", &self.ScopeId)
5490             .finish()
5491     }
5492 }
5493 #[cfg(feature = "Win32_Foundation")]
5494 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO_V6 {
eq(&self, other: &Self) -> bool5495     fn eq(&self, other: &Self) -> bool {
5496         self.SubnetAddress == other.SubnetAddress && self.Prefix == other.Prefix && self.Preference == other.Preference && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.State == other.State && self.ScopeId == other.ScopeId
5497     }
5498 }
5499 #[cfg(feature = "Win32_Foundation")]
5500 impl ::std::cmp::Eq for DHCP_SUBNET_INFO_V6 {}
5501 #[cfg(feature = "Win32_Foundation")]
5502 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO_V6 {
5503     type Abi = Self;
5504     type DefaultType = Self;
5505 }
5506 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5507 #[repr(C)]
5508 #[cfg(feature = "Win32_Foundation")]
5509 pub struct DHCP_SUBNET_INFO_VQ {
5510     pub SubnetAddress: u32,
5511     pub SubnetMask: u32,
5512     pub SubnetName: super::super::Foundation::PWSTR,
5513     pub SubnetComment: super::super::Foundation::PWSTR,
5514     pub PrimaryHost: DHCP_HOST_INFO,
5515     pub SubnetState: DHCP_SUBNET_STATE,
5516     pub QuarantineOn: u32,
5517     pub Reserved1: u32,
5518     pub Reserved2: u32,
5519     pub Reserved3: i64,
5520     pub Reserved4: i64,
5521 }
5522 #[cfg(feature = "Win32_Foundation")]
5523 impl DHCP_SUBNET_INFO_VQ {}
5524 #[cfg(feature = "Win32_Foundation")]
5525 impl ::std::default::Default for DHCP_SUBNET_INFO_VQ {
default() -> Self5526     fn default() -> Self {
5527         unsafe { ::std::mem::zeroed() }
5528     }
5529 }
5530 #[cfg(feature = "Win32_Foundation")]
5531 impl ::std::fmt::Debug for DHCP_SUBNET_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5532     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5533         fmt.debug_struct("DHCP_SUBNET_INFO_VQ")
5534             .field("SubnetAddress", &self.SubnetAddress)
5535             .field("SubnetMask", &self.SubnetMask)
5536             .field("SubnetName", &self.SubnetName)
5537             .field("SubnetComment", &self.SubnetComment)
5538             .field("PrimaryHost", &self.PrimaryHost)
5539             .field("SubnetState", &self.SubnetState)
5540             .field("QuarantineOn", &self.QuarantineOn)
5541             .field("Reserved1", &self.Reserved1)
5542             .field("Reserved2", &self.Reserved2)
5543             .field("Reserved3", &self.Reserved3)
5544             .field("Reserved4", &self.Reserved4)
5545             .finish()
5546     }
5547 }
5548 #[cfg(feature = "Win32_Foundation")]
5549 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO_VQ {
eq(&self, other: &Self) -> bool5550     fn eq(&self, other: &Self) -> bool {
5551         self.SubnetAddress == other.SubnetAddress && self.SubnetMask == other.SubnetMask && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.PrimaryHost == other.PrimaryHost && self.SubnetState == other.SubnetState && self.QuarantineOn == other.QuarantineOn && self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2 && self.Reserved3 == other.Reserved3 && self.Reserved4 == other.Reserved4
5552     }
5553 }
5554 #[cfg(feature = "Win32_Foundation")]
5555 impl ::std::cmp::Eq for DHCP_SUBNET_INFO_VQ {}
5556 #[cfg(feature = "Win32_Foundation")]
5557 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO_VQ {
5558     type Abi = Self;
5559     type DefaultType = Self;
5560 }
5561 pub const DHCP_SUBNET_INFO_VQ_FLAG_QUARANTINE: u32 = 1u32;
5562 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5563 #[repr(transparent)]
5564 pub struct DHCP_SUBNET_STATE(pub i32);
5565 pub const DhcpSubnetEnabled: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(0i32);
5566 pub const DhcpSubnetDisabled: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(1i32);
5567 pub const DhcpSubnetEnabledSwitched: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(2i32);
5568 pub const DhcpSubnetDisabledSwitched: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(3i32);
5569 pub const DhcpSubnetInvalidState: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(4i32);
5570 impl ::std::convert::From<i32> for DHCP_SUBNET_STATE {
from(value: i32) -> Self5571     fn from(value: i32) -> Self {
5572         Self(value)
5573     }
5574 }
5575 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_STATE {
5576     type Abi = Self;
5577     type DefaultType = Self;
5578 }
5579 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5580 #[repr(C)]
5581 #[cfg(feature = "Win32_Foundation")]
5582 pub struct DHCP_SUPER_SCOPE_TABLE {
5583     pub cEntries: u32,
5584     pub pEntries: *mut DHCP_SUPER_SCOPE_TABLE_ENTRY,
5585 }
5586 #[cfg(feature = "Win32_Foundation")]
5587 impl DHCP_SUPER_SCOPE_TABLE {}
5588 #[cfg(feature = "Win32_Foundation")]
5589 impl ::std::default::Default for DHCP_SUPER_SCOPE_TABLE {
default() -> Self5590     fn default() -> Self {
5591         unsafe { ::std::mem::zeroed() }
5592     }
5593 }
5594 #[cfg(feature = "Win32_Foundation")]
5595 impl ::std::fmt::Debug for DHCP_SUPER_SCOPE_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5596     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5597         fmt.debug_struct("DHCP_SUPER_SCOPE_TABLE").field("cEntries", &self.cEntries).field("pEntries", &self.pEntries).finish()
5598     }
5599 }
5600 #[cfg(feature = "Win32_Foundation")]
5601 impl ::std::cmp::PartialEq for DHCP_SUPER_SCOPE_TABLE {
eq(&self, other: &Self) -> bool5602     fn eq(&self, other: &Self) -> bool {
5603         self.cEntries == other.cEntries && self.pEntries == other.pEntries
5604     }
5605 }
5606 #[cfg(feature = "Win32_Foundation")]
5607 impl ::std::cmp::Eq for DHCP_SUPER_SCOPE_TABLE {}
5608 #[cfg(feature = "Win32_Foundation")]
5609 unsafe impl ::windows::runtime::Abi for DHCP_SUPER_SCOPE_TABLE {
5610     type Abi = Self;
5611     type DefaultType = Self;
5612 }
5613 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5614 #[repr(C)]
5615 #[cfg(feature = "Win32_Foundation")]
5616 pub struct DHCP_SUPER_SCOPE_TABLE_ENTRY {
5617     pub SubnetAddress: u32,
5618     pub SuperScopeNumber: u32,
5619     pub NextInSuperScope: u32,
5620     pub SuperScopeName: super::super::Foundation::PWSTR,
5621 }
5622 #[cfg(feature = "Win32_Foundation")]
5623 impl DHCP_SUPER_SCOPE_TABLE_ENTRY {}
5624 #[cfg(feature = "Win32_Foundation")]
5625 impl ::std::default::Default for DHCP_SUPER_SCOPE_TABLE_ENTRY {
default() -> Self5626     fn default() -> Self {
5627         unsafe { ::std::mem::zeroed() }
5628     }
5629 }
5630 #[cfg(feature = "Win32_Foundation")]
5631 impl ::std::fmt::Debug for DHCP_SUPER_SCOPE_TABLE_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5632     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5633         fmt.debug_struct("DHCP_SUPER_SCOPE_TABLE_ENTRY").field("SubnetAddress", &self.SubnetAddress).field("SuperScopeNumber", &self.SuperScopeNumber).field("NextInSuperScope", &self.NextInSuperScope).field("SuperScopeName", &self.SuperScopeName).finish()
5634     }
5635 }
5636 #[cfg(feature = "Win32_Foundation")]
5637 impl ::std::cmp::PartialEq for DHCP_SUPER_SCOPE_TABLE_ENTRY {
eq(&self, other: &Self) -> bool5638     fn eq(&self, other: &Self) -> bool {
5639         self.SubnetAddress == other.SubnetAddress && self.SuperScopeNumber == other.SuperScopeNumber && self.NextInSuperScope == other.NextInSuperScope && self.SuperScopeName == other.SuperScopeName
5640     }
5641 }
5642 #[cfg(feature = "Win32_Foundation")]
5643 impl ::std::cmp::Eq for DHCP_SUPER_SCOPE_TABLE_ENTRY {}
5644 #[cfg(feature = "Win32_Foundation")]
5645 unsafe impl ::windows::runtime::Abi for DHCP_SUPER_SCOPE_TABLE_ENTRY {
5646     type Abi = Self;
5647     type DefaultType = Self;
5648 }
5649 pub const DNS_FLAG_CLEANUP_EXPIRED: u32 = 4u32;
5650 pub const DNS_FLAG_DISABLE_PTR_UPDATE: u32 = 64u32;
5651 pub const DNS_FLAG_ENABLED: u32 = 1u32;
5652 pub const DNS_FLAG_HAS_DNS_SUFFIX: u32 = 128u32;
5653 pub const DNS_FLAG_UPDATE_BOTH_ALWAYS: u32 = 16u32;
5654 pub const DNS_FLAG_UPDATE_DHCID: u32 = 32u32;
5655 pub const DNS_FLAG_UPDATE_DOWNLEVEL: u32 = 2u32;
5656 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5657 #[repr(C)]
5658 pub struct DWORD_DWORD {
5659     pub DWord1: u32,
5660     pub DWord2: u32,
5661 }
5662 impl DWORD_DWORD {}
5663 impl ::std::default::Default for DWORD_DWORD {
default() -> Self5664     fn default() -> Self {
5665         unsafe { ::std::mem::zeroed() }
5666     }
5667 }
5668 impl ::std::fmt::Debug for DWORD_DWORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5669     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5670         fmt.debug_struct("DWORD_DWORD").field("DWord1", &self.DWord1).field("DWord2", &self.DWord2).finish()
5671     }
5672 }
5673 impl ::std::cmp::PartialEq for DWORD_DWORD {
eq(&self, other: &Self) -> bool5674     fn eq(&self, other: &Self) -> bool {
5675         self.DWord1 == other.DWord1 && self.DWord2 == other.DWord2
5676     }
5677 }
5678 impl ::std::cmp::Eq for DWORD_DWORD {}
5679 unsafe impl ::windows::runtime::Abi for DWORD_DWORD {
5680     type Abi = Self;
5681     type DefaultType = Self;
5682 }
5683 #[cfg(feature = "Win32_Foundation")]
5684 #[inline]
DhcpAddFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: Param2) -> u325685 pub unsafe fn DhcpAddFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: Param2) -> u32 {
5686     #[cfg(windows)]
5687     {
5688         #[link(name = "windows")]
5689         extern "system" {
5690             fn DhcpAddFilterV4(serveripaddress: super::super::Foundation::PWSTR, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: super::super::Foundation::BOOL) -> u32;
5691         }
5692         ::std::mem::transmute(DhcpAddFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(addfilterinfo), forceflag.into_param().abi()))
5693     }
5694     #[cfg(not(windows))]
5695     unimplemented!("Unsupported target OS");
5696 }
5697 #[cfg(feature = "Win32_Foundation")]
5698 #[inline]
DhcpAddSecurityGroup<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pserver: Param0) -> u325699 pub unsafe fn DhcpAddSecurityGroup<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pserver: Param0) -> u32 {
5700     #[cfg(windows)]
5701     {
5702         #[link(name = "windows")]
5703         extern "system" {
5704             fn DhcpAddSecurityGroup(pserver: super::super::Foundation::PWSTR) -> u32;
5705         }
5706         ::std::mem::transmute(DhcpAddSecurityGroup(pserver.into_param().abi()))
5707     }
5708     #[cfg(not(windows))]
5709     unimplemented!("Unsupported target OS");
5710 }
5711 #[cfg(feature = "Win32_Foundation")]
5712 #[inline]
DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u325713 pub unsafe fn DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
5714     #[cfg(windows)]
5715     {
5716         #[link(name = "windows")]
5717         extern "system" {
5718             fn DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
5719         }
5720         ::std::mem::transmute(DhcpAddServer(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(newserver), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
5721     }
5722     #[cfg(not(windows))]
5723     unimplemented!("Unsupported target OS");
5724 }
5725 #[cfg(feature = "Win32_Foundation")]
5726 #[inline]
DhcpAddSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u325727 pub unsafe fn DhcpAddSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u32 {
5728     #[cfg(windows)]
5729     {
5730         #[link(name = "windows")]
5731         extern "system" {
5732             fn DhcpAddSubnetElement(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u32;
5733         }
5734         ::std::mem::transmute(DhcpAddSubnetElement(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5735     }
5736     #[cfg(not(windows))]
5737     unimplemented!("Unsupported target OS");
5738 }
5739 #[cfg(feature = "Win32_Foundation")]
5740 #[inline]
DhcpAddSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u325741 pub unsafe fn DhcpAddSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u32 {
5742     #[cfg(windows)]
5743     {
5744         #[link(name = "windows")]
5745         extern "system" {
5746             fn DhcpAddSubnetElementV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u32;
5747         }
5748         ::std::mem::transmute(DhcpAddSubnetElementV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5749     }
5750     #[cfg(not(windows))]
5751     unimplemented!("Unsupported target OS");
5752 }
5753 #[cfg(feature = "Win32_Foundation")]
5754 #[inline]
DhcpAddSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u325755 pub unsafe fn DhcpAddSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u32 {
5756     #[cfg(windows)]
5757     {
5758         #[link(name = "windows")]
5759         extern "system" {
5760             fn DhcpAddSubnetElementV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u32;
5761         }
5762         ::std::mem::transmute(DhcpAddSubnetElementV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5763     }
5764     #[cfg(not(windows))]
5765     unimplemented!("Unsupported target OS");
5766 }
5767 #[cfg(feature = "Win32_Foundation")]
5768 #[inline]
DhcpAddSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u325769 pub unsafe fn DhcpAddSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u32 {
5770     #[cfg(windows)]
5771     {
5772         #[link(name = "windows")]
5773         extern "system" {
5774             fn DhcpAddSubnetElementV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u32;
5775         }
5776         ::std::mem::transmute(DhcpAddSubnetElementV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(addelementinfo)))
5777     }
5778     #[cfg(not(windows))]
5779     unimplemented!("Unsupported target OS");
5780 }
5781 #[cfg(feature = "Win32_Foundation")]
5782 #[inline]
DhcpAuditLogGetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u325783 pub unsafe fn DhcpAuditLogGetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u32 {
5784     #[cfg(windows)]
5785     {
5786         #[link(name = "windows")]
5787         extern "system" {
5788             fn DhcpAuditLogGetParams(serveripaddress: super::super::Foundation::PWSTR, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u32;
5789         }
5790         ::std::mem::transmute(DhcpAuditLogGetParams(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(auditlogdir), ::std::mem::transmute(diskcheckinterval), ::std::mem::transmute(maxlogfilessize), ::std::mem::transmute(minspaceondisk)))
5791     }
5792     #[cfg(not(windows))]
5793     unimplemented!("Unsupported target OS");
5794 }
5795 #[cfg(feature = "Win32_Foundation")]
5796 #[inline]
DhcpAuditLogSetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: Param2, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u325797 pub unsafe fn DhcpAuditLogSetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: Param2, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u32 {
5798     #[cfg(windows)]
5799     {
5800         #[link(name = "windows")]
5801         extern "system" {
5802             fn DhcpAuditLogSetParams(serveripaddress: super::super::Foundation::PWSTR, flags: u32, auditlogdir: super::super::Foundation::PWSTR, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u32;
5803         }
5804         ::std::mem::transmute(DhcpAuditLogSetParams(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), auditlogdir.into_param().abi(), ::std::mem::transmute(diskcheckinterval), ::std::mem::transmute(maxlogfilessize), ::std::mem::transmute(minspaceondisk)))
5805     }
5806     #[cfg(not(windows))]
5807     unimplemented!("Unsupported target OS");
5808 }
5809 #[inline]
DhcpCApiCleanup()5810 pub unsafe fn DhcpCApiCleanup() {
5811     #[cfg(windows)]
5812     {
5813         #[link(name = "windows")]
5814         extern "system" {
5815             fn DhcpCApiCleanup();
5816         }
5817         ::std::mem::transmute(DhcpCApiCleanup())
5818     }
5819     #[cfg(not(windows))]
5820     unimplemented!("Unsupported target OS");
5821 }
5822 #[inline]
DhcpCApiInitialize(version: *mut u32) -> u325823 pub unsafe fn DhcpCApiInitialize(version: *mut u32) -> u32 {
5824     #[cfg(windows)]
5825     {
5826         #[link(name = "windows")]
5827         extern "system" {
5828             fn DhcpCApiInitialize(version: *mut u32) -> u32;
5829         }
5830         ::std::mem::transmute(DhcpCApiInitialize(::std::mem::transmute(version)))
5831     }
5832     #[cfg(not(windows))]
5833     unimplemented!("Unsupported target OS");
5834 }
5835 #[cfg(feature = "Win32_Foundation")]
5836 #[inline]
DhcpCreateClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u325837 pub unsafe fn DhcpCreateClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32 {
5838     #[cfg(windows)]
5839     {
5840         #[link(name = "windows")]
5841         extern "system" {
5842             fn DhcpCreateClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32;
5843         }
5844         ::std::mem::transmute(DhcpCreateClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
5845     }
5846     #[cfg(not(windows))]
5847     unimplemented!("Unsupported target OS");
5848 }
5849 #[cfg(feature = "Win32_Foundation")]
5850 #[inline]
DhcpCreateClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u325851 pub unsafe fn DhcpCreateClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32 {
5852     #[cfg(windows)]
5853     {
5854         #[link(name = "windows")]
5855         extern "system" {
5856             fn DhcpCreateClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32;
5857         }
5858         ::std::mem::transmute(DhcpCreateClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
5859     }
5860     #[cfg(not(windows))]
5861     unimplemented!("Unsupported target OS");
5862 }
5863 #[cfg(feature = "Win32_Foundation")]
5864 #[inline]
DhcpCreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u325865 pub unsafe fn DhcpCreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u32 {
5866     #[cfg(windows)]
5867     {
5868         #[link(name = "windows")]
5869         extern "system" {
5870             fn DhcpCreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO) -> u32;
5871         }
5872         ::std::mem::transmute(DhcpCreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5873     }
5874     #[cfg(not(windows))]
5875     unimplemented!("Unsupported target OS");
5876 }
5877 #[cfg(feature = "Win32_Foundation")]
5878 #[inline]
DhcpCreateClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u325879 pub unsafe fn DhcpCreateClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32 {
5880     #[cfg(windows)]
5881     {
5882         #[link(name = "windows")]
5883         extern "system" {
5884             fn DhcpCreateClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32;
5885         }
5886         ::std::mem::transmute(DhcpCreateClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5887     }
5888     #[cfg(not(windows))]
5889     unimplemented!("Unsupported target OS");
5890 }
5891 #[cfg(feature = "Win32_Foundation")]
5892 #[inline]
DhcpCreateClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u325893 pub unsafe fn DhcpCreateClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32 {
5894     #[cfg(windows)]
5895     {
5896         #[link(name = "windows")]
5897         extern "system" {
5898             fn DhcpCreateClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32;
5899         }
5900         ::std::mem::transmute(DhcpCreateClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5901     }
5902     #[cfg(not(windows))]
5903     unimplemented!("Unsupported target OS");
5904 }
5905 #[cfg(feature = "Win32_Foundation")]
5906 #[inline]
DhcpCreateOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u325907 pub unsafe fn DhcpCreateOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32 {
5908     #[cfg(windows)]
5909     {
5910         #[link(name = "windows")]
5911         extern "system" {
5912             fn DhcpCreateOption(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32;
5913         }
5914         ::std::mem::transmute(DhcpCreateOption(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
5915     }
5916     #[cfg(not(windows))]
5917     unimplemented!("Unsupported target OS");
5918 }
5919 #[cfg(feature = "Win32_Foundation")]
5920 #[inline]
DhcpCreateOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u325921 pub unsafe fn DhcpCreateOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
5922     #[cfg(windows)]
5923     {
5924         #[link(name = "windows")]
5925         extern "system" {
5926             fn DhcpCreateOptionV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
5927         }
5928         ::std::mem::transmute(DhcpCreateOptionV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
5929     }
5930     #[cfg(not(windows))]
5931     unimplemented!("Unsupported target OS");
5932 }
5933 #[cfg(feature = "Win32_Foundation")]
5934 #[inline]
DhcpCreateOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u325935 pub unsafe fn DhcpCreateOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
5936     #[cfg(windows)]
5937     {
5938         #[link(name = "windows")]
5939         extern "system" {
5940             fn DhcpCreateOptionV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
5941         }
5942         ::std::mem::transmute(DhcpCreateOptionV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
5943     }
5944     #[cfg(not(windows))]
5945     unimplemented!("Unsupported target OS");
5946 }
5947 #[cfg(feature = "Win32_Foundation")]
5948 #[inline]
DhcpCreateSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u325949 pub unsafe fn DhcpCreateSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32 {
5950     #[cfg(windows)]
5951     {
5952         #[link(name = "windows")]
5953         extern "system" {
5954             fn DhcpCreateSubnet(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32;
5955         }
5956         ::std::mem::transmute(DhcpCreateSubnet(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
5957     }
5958     #[cfg(not(windows))]
5959     unimplemented!("Unsupported target OS");
5960 }
5961 #[cfg(feature = "Win32_Foundation")]
5962 #[inline]
DhcpCreateSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u325963 pub unsafe fn DhcpCreateSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32 {
5964     #[cfg(windows)]
5965     {
5966         #[link(name = "windows")]
5967         extern "system" {
5968             fn DhcpCreateSubnetV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32;
5969         }
5970         ::std::mem::transmute(DhcpCreateSubnetV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
5971     }
5972     #[cfg(not(windows))]
5973     unimplemented!("Unsupported target OS");
5974 }
5975 #[cfg(feature = "Win32_Foundation")]
5976 #[inline]
DhcpCreateSubnetVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u325977 pub unsafe fn DhcpCreateSubnetVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32 {
5978     #[cfg(windows)]
5979     {
5980         #[link(name = "windows")]
5981         extern "system" {
5982             fn DhcpCreateSubnetVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32;
5983         }
5984         ::std::mem::transmute(DhcpCreateSubnetVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
5985     }
5986     #[cfg(not(windows))]
5987     unimplemented!("Unsupported target OS");
5988 }
5989 #[inline]
DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u325990 pub unsafe fn DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u32 {
5991     #[cfg(windows)]
5992     {
5993         #[link(name = "windows")]
5994         extern "system" {
5995             fn DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u32;
5996         }
5997         ::std::mem::transmute(DhcpDeRegisterParamChange(::std::mem::transmute(flags), ::std::mem::transmute(reserved), ::std::mem::transmute(event)))
5998     }
5999     #[cfg(not(windows))]
6000     unimplemented!("Unsupported target OS");
6001 }
6002 #[cfg(feature = "Win32_Foundation")]
6003 #[inline]
DhcpDeleteClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u326004 pub unsafe fn DhcpDeleteClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u32 {
6005     #[cfg(windows)]
6006     {
6007         #[link(name = "windows")]
6008         extern "system" {
6009             fn DhcpDeleteClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classname: super::super::Foundation::PWSTR) -> u32;
6010         }
6011         ::std::mem::transmute(DhcpDeleteClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), classname.into_param().abi()))
6012     }
6013     #[cfg(not(windows))]
6014     unimplemented!("Unsupported target OS");
6015 }
6016 #[cfg(feature = "Win32_Foundation")]
6017 #[inline]
DhcpDeleteClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u326018 pub unsafe fn DhcpDeleteClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u32 {
6019     #[cfg(windows)]
6020     {
6021         #[link(name = "windows")]
6022         extern "system" {
6023             fn DhcpDeleteClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classname: super::super::Foundation::PWSTR) -> u32;
6024         }
6025         ::std::mem::transmute(DhcpDeleteClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), classname.into_param().abi()))
6026     }
6027     #[cfg(not(windows))]
6028     unimplemented!("Unsupported target OS");
6029 }
6030 #[cfg(feature = "Win32_Foundation")]
6031 #[inline]
DhcpDeleteClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO) -> u326032 pub unsafe fn DhcpDeleteClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO) -> u32 {
6033     #[cfg(windows)]
6034     {
6035         #[link(name = "windows")]
6036         extern "system" {
6037             fn DhcpDeleteClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_SEARCH_INFO) -> u32;
6038         }
6039         ::std::mem::transmute(DhcpDeleteClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
6040     }
6041     #[cfg(not(windows))]
6042     unimplemented!("Unsupported target OS");
6043 }
6044 #[cfg(feature = "Win32_Foundation")]
6045 #[inline]
DhcpDeleteClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u326046 pub unsafe fn DhcpDeleteClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u32 {
6047     #[cfg(windows)]
6048     {
6049         #[link(name = "windows")]
6050         extern "system" {
6051             fn DhcpDeleteClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u32;
6052         }
6053         ::std::mem::transmute(DhcpDeleteClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
6054     }
6055     #[cfg(not(windows))]
6056     unimplemented!("Unsupported target OS");
6057 }
6058 #[cfg(feature = "Win32_Foundation")]
6059 #[inline]
DhcpDeleteFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u326060 pub unsafe fn DhcpDeleteFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u32 {
6061     #[cfg(windows)]
6062     {
6063         #[link(name = "windows")]
6064         extern "system" {
6065             fn DhcpDeleteFilterV4(serveripaddress: super::super::Foundation::PWSTR, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u32;
6066         }
6067         ::std::mem::transmute(DhcpDeleteFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(deletefilterinfo)))
6068     }
6069     #[cfg(not(windows))]
6070     unimplemented!("Unsupported target OS");
6071 }
6072 #[cfg(feature = "Win32_Foundation")]
6073 #[inline]
DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u326074 pub unsafe fn DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
6075     #[cfg(windows)]
6076     {
6077         #[link(name = "windows")]
6078         extern "system" {
6079             fn DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
6080         }
6081         ::std::mem::transmute(DhcpDeleteServer(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(newserver), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
6082     }
6083     #[cfg(not(windows))]
6084     unimplemented!("Unsupported target OS");
6085 }
6086 #[cfg(feature = "Win32_Foundation")]
6087 #[inline]
DhcpDeleteSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u326088 pub unsafe fn DhcpDeleteSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u32 {
6089     #[cfg(windows)]
6090     {
6091         #[link(name = "windows")]
6092         extern "system" {
6093             fn DhcpDeleteSubnet(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u32;
6094         }
6095         ::std::mem::transmute(DhcpDeleteSubnet(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(forceflag)))
6096     }
6097     #[cfg(not(windows))]
6098     unimplemented!("Unsupported target OS");
6099 }
6100 #[cfg(feature = "Win32_Foundation")]
6101 #[inline]
DhcpDeleteSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, forceflag: DHCP_FORCE_FLAG) -> u326102 pub unsafe fn DhcpDeleteSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, forceflag: DHCP_FORCE_FLAG) -> u32 {
6103     #[cfg(windows)]
6104     {
6105         #[link(name = "windows")]
6106         extern "system" {
6107             fn DhcpDeleteSubnetV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, forceflag: DHCP_FORCE_FLAG) -> u32;
6108         }
6109         ::std::mem::transmute(DhcpDeleteSubnetV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(forceflag)))
6110     }
6111     #[cfg(not(windows))]
6112     unimplemented!("Unsupported target OS");
6113 }
6114 #[cfg(feature = "Win32_Foundation")]
6115 #[inline]
DhcpDeleteSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopename: Param1) -> u326116 pub unsafe fn DhcpDeleteSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopename: Param1) -> u32 {
6117     #[cfg(windows)]
6118     {
6119         #[link(name = "windows")]
6120         extern "system" {
6121             fn DhcpDeleteSuperScopeV4(serveripaddress: super::super::Foundation::PWSTR, superscopename: super::super::Foundation::PWSTR) -> u32;
6122         }
6123         ::std::mem::transmute(DhcpDeleteSuperScopeV4(serveripaddress.into_param().abi(), superscopename.into_param().abi()))
6124     }
6125     #[cfg(not(windows))]
6126     unimplemented!("Unsupported target OS");
6127 }
6128 #[inline]
DhcpDsCleanup()6129 pub unsafe fn DhcpDsCleanup() {
6130     #[cfg(windows)]
6131     {
6132         #[link(name = "windows")]
6133         extern "system" {
6134             fn DhcpDsCleanup();
6135         }
6136         ::std::mem::transmute(DhcpDsCleanup())
6137     }
6138     #[cfg(not(windows))]
6139     unimplemented!("Unsupported target OS");
6140 }
6141 #[inline]
DhcpDsInit() -> u326142 pub unsafe fn DhcpDsInit() -> u32 {
6143     #[cfg(windows)]
6144     {
6145         #[link(name = "windows")]
6146         extern "system" {
6147             fn DhcpDsInit() -> u32;
6148         }
6149         ::std::mem::transmute(DhcpDsInit())
6150     }
6151     #[cfg(not(windows))]
6152     unimplemented!("Unsupported target OS");
6153 }
6154 #[cfg(feature = "Win32_Foundation")]
6155 #[inline]
DhcpEnumClasses<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u326156 pub unsafe fn DhcpEnumClasses<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u32 {
6157     #[cfg(windows)]
6158     {
6159         #[link(name = "windows")]
6160         extern "system" {
6161             fn DhcpEnumClasses(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u32;
6162         }
6163         ::std::mem::transmute(DhcpEnumClasses(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(classinfoarray), ::std::mem::transmute(nread), ::std::mem::transmute(ntotal)))
6164     }
6165     #[cfg(not(windows))]
6166     unimplemented!("Unsupported target OS");
6167 }
6168 #[cfg(feature = "Win32_Foundation")]
6169 #[inline]
DhcpEnumClassesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u326170 pub unsafe fn DhcpEnumClassesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u32 {
6171     #[cfg(windows)]
6172     {
6173         #[link(name = "windows")]
6174         extern "system" {
6175             fn DhcpEnumClassesV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u32;
6176         }
6177         ::std::mem::transmute(DhcpEnumClassesV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(classinfoarray), ::std::mem::transmute(nread), ::std::mem::transmute(ntotal)))
6178     }
6179     #[cfg(not(windows))]
6180     unimplemented!("Unsupported target OS");
6181 }
6182 #[cfg(feature = "Win32_Foundation")]
6183 #[inline]
DhcpEnumFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u326184 pub unsafe fn DhcpEnumFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6185     #[cfg(windows)]
6186     {
6187         #[link(name = "windows")]
6188         extern "system" {
6189             fn DhcpEnumFilterV4(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6190         }
6191         ::std::mem::transmute(DhcpEnumFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(listtype), ::std::mem::transmute(enumfilterinfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6192     }
6193     #[cfg(not(windows))]
6194     unimplemented!("Unsupported target OS");
6195 }
6196 #[cfg(feature = "Win32_Foundation")]
6197 #[inline]
DhcpEnumOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326198 pub unsafe fn DhcpEnumOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6199     #[cfg(windows)]
6200     {
6201         #[link(name = "windows")]
6202         extern "system" {
6203             fn DhcpEnumOptionValues(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6204         }
6205         ::std::mem::transmute(DhcpEnumOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(optionvalues), ::std::mem::transmute(optionsread), ::std::mem::transmute(optionstotal)))
6206     }
6207     #[cfg(not(windows))]
6208     unimplemented!("Unsupported target OS");
6209 }
6210 #[cfg(feature = "Win32_Foundation")]
6211 #[inline]
DhcpEnumOptionValuesV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32, ) -> u326212 pub unsafe fn DhcpEnumOptionValuesV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
6213     serveripaddress: Param0,
6214     flags: u32,
6215     classname: Param2,
6216     vendorname: Param3,
6217     scopeinfo: *mut DHCP_OPTION_SCOPE_INFO,
6218     resumehandle: *mut u32,
6219     preferredmaximum: u32,
6220     optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY,
6221     optionsread: *mut u32,
6222     optionstotal: *mut u32,
6223 ) -> u32 {
6224     #[cfg(windows)]
6225     {
6226         #[link(name = "windows")]
6227         extern "system" {
6228             fn DhcpEnumOptionValuesV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6229         }
6230         ::std::mem::transmute(DhcpEnumOptionValuesV5(
6231             serveripaddress.into_param().abi(),
6232             ::std::mem::transmute(flags),
6233             classname.into_param().abi(),
6234             vendorname.into_param().abi(),
6235             ::std::mem::transmute(scopeinfo),
6236             ::std::mem::transmute(resumehandle),
6237             ::std::mem::transmute(preferredmaximum),
6238             ::std::mem::transmute(optionvalues),
6239             ::std::mem::transmute(optionsread),
6240             ::std::mem::transmute(optionstotal),
6241         ))
6242     }
6243     #[cfg(not(windows))]
6244     unimplemented!("Unsupported target OS");
6245 }
6246 #[cfg(feature = "Win32_Foundation")]
6247 #[inline]
DhcpEnumOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32, ) -> u326248 pub unsafe fn DhcpEnumOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
6249     serveripaddress: Param0,
6250     flags: u32,
6251     classname: Param2,
6252     vendorname: Param3,
6253     scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6,
6254     resumehandle: *mut u32,
6255     preferredmaximum: u32,
6256     optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY,
6257     optionsread: *mut u32,
6258     optionstotal: *mut u32,
6259 ) -> u32 {
6260     #[cfg(windows)]
6261     {
6262         #[link(name = "windows")]
6263         extern "system" {
6264             fn DhcpEnumOptionValuesV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6265         }
6266         ::std::mem::transmute(DhcpEnumOptionValuesV6(
6267             serveripaddress.into_param().abi(),
6268             ::std::mem::transmute(flags),
6269             classname.into_param().abi(),
6270             vendorname.into_param().abi(),
6271             ::std::mem::transmute(scopeinfo),
6272             ::std::mem::transmute(resumehandle),
6273             ::std::mem::transmute(preferredmaximum),
6274             ::std::mem::transmute(optionvalues),
6275             ::std::mem::transmute(optionsread),
6276             ::std::mem::transmute(optionstotal),
6277         ))
6278     }
6279     #[cfg(not(windows))]
6280     unimplemented!("Unsupported target OS");
6281 }
6282 #[cfg(feature = "Win32_Foundation")]
6283 #[inline]
DhcpEnumOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326284 pub unsafe fn DhcpEnumOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6285     #[cfg(windows)]
6286     {
6287         #[link(name = "windows")]
6288         extern "system" {
6289             fn DhcpEnumOptions(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6290         }
6291         ::std::mem::transmute(DhcpEnumOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(options), ::std::mem::transmute(optionsread), ::std::mem::transmute(optionstotal)))
6292     }
6293     #[cfg(not(windows))]
6294     unimplemented!("Unsupported target OS");
6295 }
6296 #[cfg(feature = "Win32_Foundation")]
6297 #[inline]
DhcpEnumOptionsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326298 pub unsafe fn DhcpEnumOptionsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6299     #[cfg(windows)]
6300     {
6301         #[link(name = "windows")]
6302         extern "system" {
6303             fn DhcpEnumOptionsV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6304         }
6305         ::std::mem::transmute(DhcpEnumOptionsV5(
6306             serveripaddress.into_param().abi(),
6307             ::std::mem::transmute(flags),
6308             classname.into_param().abi(),
6309             vendorname.into_param().abi(),
6310             ::std::mem::transmute(resumehandle),
6311             ::std::mem::transmute(preferredmaximum),
6312             ::std::mem::transmute(options),
6313             ::std::mem::transmute(optionsread),
6314             ::std::mem::transmute(optionstotal),
6315         ))
6316     }
6317     #[cfg(not(windows))]
6318     unimplemented!("Unsupported target OS");
6319 }
6320 #[cfg(feature = "Win32_Foundation")]
6321 #[inline]
DhcpEnumOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326322 pub unsafe fn DhcpEnumOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6323     #[cfg(windows)]
6324     {
6325         #[link(name = "windows")]
6326         extern "system" {
6327             fn DhcpEnumOptionsV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6328         }
6329         ::std::mem::transmute(DhcpEnumOptionsV6(
6330             serveripaddress.into_param().abi(),
6331             ::std::mem::transmute(flags),
6332             classname.into_param().abi(),
6333             vendorname.into_param().abi(),
6334             ::std::mem::transmute(resumehandle),
6335             ::std::mem::transmute(preferredmaximum),
6336             ::std::mem::transmute(options),
6337             ::std::mem::transmute(optionsread),
6338             ::std::mem::transmute(optionstotal),
6339         ))
6340     }
6341     #[cfg(not(windows))]
6342     unimplemented!("Unsupported target OS");
6343 }
6344 #[cfg(feature = "Win32_Foundation")]
6345 #[inline]
DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u326346 pub unsafe fn DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
6347     #[cfg(windows)]
6348     {
6349         #[link(name = "windows")]
6350         extern "system" {
6351             fn DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
6352         }
6353         ::std::mem::transmute(DhcpEnumServers(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(servers), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
6354     }
6355     #[cfg(not(windows))]
6356     unimplemented!("Unsupported target OS");
6357 }
6358 #[cfg(feature = "Win32_Foundation")]
6359 #[inline]
DhcpEnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u326360 pub unsafe fn DhcpEnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6361     #[cfg(windows)]
6362     {
6363         #[link(name = "windows")]
6364         extern "system" {
6365             fn DhcpEnumSubnetClients(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6366         }
6367         ::std::mem::transmute(DhcpEnumSubnetClients(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6368     }
6369     #[cfg(not(windows))]
6370     unimplemented!("Unsupported target OS");
6371 }
6372 #[cfg(feature = "Win32_Foundation")]
6373 #[inline]
DhcpEnumSubnetClientsFilterStatusInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u326374 pub unsafe fn DhcpEnumSubnetClientsFilterStatusInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6375     #[cfg(windows)]
6376     {
6377         #[link(name = "windows")]
6378         extern "system" {
6379             fn DhcpEnumSubnetClientsFilterStatusInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6380         }
6381         ::std::mem::transmute(DhcpEnumSubnetClientsFilterStatusInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6382     }
6383     #[cfg(not(windows))]
6384     unimplemented!("Unsupported target OS");
6385 }
6386 #[cfg(feature = "Win32_Foundation")]
6387 #[inline]
DhcpEnumSubnetClientsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u326388 pub unsafe fn DhcpEnumSubnetClientsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6389     #[cfg(windows)]
6390     {
6391         #[link(name = "windows")]
6392         extern "system" {
6393             fn DhcpEnumSubnetClientsV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6394         }
6395         ::std::mem::transmute(DhcpEnumSubnetClientsV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6396     }
6397     #[cfg(not(windows))]
6398     unimplemented!("Unsupported target OS");
6399 }
6400 #[cfg(feature = "Win32_Foundation")]
6401 #[inline]
DhcpEnumSubnetClientsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u326402 pub unsafe fn DhcpEnumSubnetClientsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6403     #[cfg(windows)]
6404     {
6405         #[link(name = "windows")]
6406         extern "system" {
6407             fn DhcpEnumSubnetClientsV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6408         }
6409         ::std::mem::transmute(DhcpEnumSubnetClientsV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6410     }
6411     #[cfg(not(windows))]
6412     unimplemented!("Unsupported target OS");
6413 }
6414 #[cfg(feature = "Win32_Foundation")]
6415 #[inline]
DhcpEnumSubnetClientsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u326416 pub unsafe fn DhcpEnumSubnetClientsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6417     #[cfg(windows)]
6418     {
6419         #[link(name = "windows")]
6420         extern "system" {
6421             fn DhcpEnumSubnetClientsV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6422         }
6423         ::std::mem::transmute(DhcpEnumSubnetClientsV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6424     }
6425     #[cfg(not(windows))]
6426     unimplemented!("Unsupported target OS");
6427 }
6428 #[cfg(feature = "Win32_Foundation")]
6429 #[inline]
DhcpEnumSubnetClientsVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u326430 pub unsafe fn DhcpEnumSubnetClientsVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6431     #[cfg(windows)]
6432     {
6433         #[link(name = "windows")]
6434         extern "system" {
6435             fn DhcpEnumSubnetClientsVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6436         }
6437         ::std::mem::transmute(DhcpEnumSubnetClientsVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6438     }
6439     #[cfg(not(windows))]
6440     unimplemented!("Unsupported target OS");
6441 }
6442 #[cfg(feature = "Win32_Foundation")]
6443 #[inline]
DhcpEnumSubnetElements<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326444 pub unsafe fn DhcpEnumSubnetElements<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6445     #[cfg(windows)]
6446     {
6447         #[link(name = "windows")]
6448         extern "system" {
6449             fn DhcpEnumSubnetElements(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6450         }
6451         ::std::mem::transmute(DhcpEnumSubnetElements(
6452             serveripaddress.into_param().abi(),
6453             ::std::mem::transmute(subnetaddress),
6454             ::std::mem::transmute(enumelementtype),
6455             ::std::mem::transmute(resumehandle),
6456             ::std::mem::transmute(preferredmaximum),
6457             ::std::mem::transmute(enumelementinfo),
6458             ::std::mem::transmute(elementsread),
6459             ::std::mem::transmute(elementstotal),
6460         ))
6461     }
6462     #[cfg(not(windows))]
6463     unimplemented!("Unsupported target OS");
6464 }
6465 #[cfg(feature = "Win32_Foundation")]
6466 #[inline]
DhcpEnumSubnetElementsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u326467 pub unsafe fn DhcpEnumSubnetElementsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6468     #[cfg(windows)]
6469     {
6470         #[link(name = "windows")]
6471         extern "system" {
6472             fn DhcpEnumSubnetElementsV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6473         }
6474         ::std::mem::transmute(DhcpEnumSubnetElementsV4(
6475             serveripaddress.into_param().abi(),
6476             ::std::mem::transmute(subnetaddress),
6477             ::std::mem::transmute(enumelementtype),
6478             ::std::mem::transmute(resumehandle),
6479             ::std::mem::transmute(preferredmaximum),
6480             ::std::mem::transmute(enumelementinfo),
6481             ::std::mem::transmute(elementsread),
6482             ::std::mem::transmute(elementstotal),
6483         ))
6484     }
6485     #[cfg(not(windows))]
6486     unimplemented!("Unsupported target OS");
6487 }
6488 #[cfg(feature = "Win32_Foundation")]
6489 #[inline]
DhcpEnumSubnetElementsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u326490 pub unsafe fn DhcpEnumSubnetElementsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6491     #[cfg(windows)]
6492     {
6493         #[link(name = "windows")]
6494         extern "system" {
6495             fn DhcpEnumSubnetElementsV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6496         }
6497         ::std::mem::transmute(DhcpEnumSubnetElementsV5(
6498             serveripaddress.into_param().abi(),
6499             ::std::mem::transmute(subnetaddress),
6500             ::std::mem::transmute(enumelementtype),
6501             ::std::mem::transmute(resumehandle),
6502             ::std::mem::transmute(preferredmaximum),
6503             ::std::mem::transmute(enumelementinfo),
6504             ::std::mem::transmute(elementsread),
6505             ::std::mem::transmute(elementstotal),
6506         ))
6507     }
6508     #[cfg(not(windows))]
6509     unimplemented!("Unsupported target OS");
6510 }
6511 #[cfg(feature = "Win32_Foundation")]
6512 #[inline]
DhcpEnumSubnetElementsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u326513 pub unsafe fn DhcpEnumSubnetElementsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6514     #[cfg(windows)]
6515     {
6516         #[link(name = "windows")]
6517         extern "system" {
6518             fn DhcpEnumSubnetElementsV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6519         }
6520         ::std::mem::transmute(DhcpEnumSubnetElementsV6(
6521             serveripaddress.into_param().abi(),
6522             subnetaddress.into_param().abi(),
6523             ::std::mem::transmute(enumelementtype),
6524             ::std::mem::transmute(resumehandle),
6525             ::std::mem::transmute(preferredmaximum),
6526             ::std::mem::transmute(enumelementinfo),
6527             ::std::mem::transmute(elementsread),
6528             ::std::mem::transmute(elementstotal),
6529         ))
6530     }
6531     #[cfg(not(windows))]
6532     unimplemented!("Unsupported target OS");
6533 }
6534 #[cfg(feature = "Win32_Foundation")]
6535 #[inline]
DhcpEnumSubnets<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326536 pub unsafe fn DhcpEnumSubnets<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6537     #[cfg(windows)]
6538     {
6539         #[link(name = "windows")]
6540         extern "system" {
6541             fn DhcpEnumSubnets(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6542         }
6543         ::std::mem::transmute(DhcpEnumSubnets(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enuminfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6544     }
6545     #[cfg(not(windows))]
6546     unimplemented!("Unsupported target OS");
6547 }
6548 #[cfg(feature = "Win32_Foundation")]
6549 #[inline]
DhcpEnumSubnetsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326550 pub unsafe fn DhcpEnumSubnetsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6551     #[cfg(windows)]
6552     {
6553         #[link(name = "windows")]
6554         extern "system" {
6555             fn DhcpEnumSubnetsV6(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6556         }
6557         ::std::mem::transmute(DhcpEnumSubnetsV6(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enuminfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6558     }
6559     #[cfg(not(windows))]
6560     unimplemented!("Unsupported target OS");
6561 }
6562 #[cfg(feature = "Win32_Foundation")]
6563 #[inline]
DhcpGetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u326564 pub unsafe fn DhcpGetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32 {
6565     #[cfg(windows)]
6566     {
6567         #[link(name = "windows")]
6568         extern "system" {
6569             fn DhcpGetAllOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32;
6570         }
6571         ::std::mem::transmute(DhcpGetAllOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
6572     }
6573     #[cfg(not(windows))]
6574     unimplemented!("Unsupported target OS");
6575 }
6576 #[cfg(feature = "Win32_Foundation")]
6577 #[inline]
DhcpGetAllOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u326578 pub unsafe fn DhcpGetAllOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32 {
6579     #[cfg(windows)]
6580     {
6581         #[link(name = "windows")]
6582         extern "system" {
6583             fn DhcpGetAllOptionValuesV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32;
6584         }
6585         ::std::mem::transmute(DhcpGetAllOptionValuesV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
6586     }
6587     #[cfg(not(windows))]
6588     unimplemented!("Unsupported target OS");
6589 }
6590 #[cfg(feature = "Win32_Foundation")]
6591 #[inline]
DhcpGetAllOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u326592 pub unsafe fn DhcpGetAllOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32 {
6593     #[cfg(windows)]
6594     {
6595         #[link(name = "windows")]
6596         extern "system" {
6597             fn DhcpGetAllOptions(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32;
6598         }
6599         ::std::mem::transmute(DhcpGetAllOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionstruct)))
6600     }
6601     #[cfg(not(windows))]
6602     unimplemented!("Unsupported target OS");
6603 }
6604 #[cfg(feature = "Win32_Foundation")]
6605 #[inline]
DhcpGetAllOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u326606 pub unsafe fn DhcpGetAllOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32 {
6607     #[cfg(windows)]
6608     {
6609         #[link(name = "windows")]
6610         extern "system" {
6611             fn DhcpGetAllOptionsV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32;
6612         }
6613         ::std::mem::transmute(DhcpGetAllOptionsV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionstruct)))
6614     }
6615     #[cfg(not(windows))]
6616     unimplemented!("Unsupported target OS");
6617 }
6618 #[cfg(feature = "Win32_Foundation")]
6619 #[inline]
DhcpGetClassInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u326620 pub unsafe fn DhcpGetClassInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u32 {
6621     #[cfg(windows)]
6622     {
6623         #[link(name = "windows")]
6624         extern "system" {
6625             fn DhcpGetClassInfo(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u32;
6626         }
6627         ::std::mem::transmute(DhcpGetClassInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(partialclassinfo), ::std::mem::transmute(filledclassinfo)))
6628     }
6629     #[cfg(not(windows))]
6630     unimplemented!("Unsupported target OS");
6631 }
6632 #[cfg(feature = "Win32_Foundation")]
6633 #[inline]
DhcpGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u326634 pub unsafe fn DhcpGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u32 {
6635     #[cfg(windows)]
6636     {
6637         #[link(name = "windows")]
6638         extern "system" {
6639             fn DhcpGetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u32;
6640         }
6641         ::std::mem::transmute(DhcpGetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6642     }
6643     #[cfg(not(windows))]
6644     unimplemented!("Unsupported target OS");
6645 }
6646 #[cfg(feature = "Win32_Foundation")]
6647 #[inline]
DhcpGetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u326648 pub unsafe fn DhcpGetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u32 {
6649     #[cfg(windows)]
6650     {
6651         #[link(name = "windows")]
6652         extern "system" {
6653             fn DhcpGetClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u32;
6654         }
6655         ::std::mem::transmute(DhcpGetClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6656     }
6657     #[cfg(not(windows))]
6658     unimplemented!("Unsupported target OS");
6659 }
6660 #[cfg(feature = "Win32_Foundation")]
6661 #[inline]
DhcpGetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u326662 pub unsafe fn DhcpGetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u32 {
6663     #[cfg(windows)]
6664     {
6665         #[link(name = "windows")]
6666         extern "system" {
6667             fn DhcpGetClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u32;
6668         }
6669         ::std::mem::transmute(DhcpGetClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6670     }
6671     #[cfg(not(windows))]
6672     unimplemented!("Unsupported target OS");
6673 }
6674 #[cfg(feature = "Win32_Foundation")]
6675 #[inline]
DhcpGetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u326676 pub unsafe fn DhcpGetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u32 {
6677     #[cfg(windows)]
6678     {
6679         #[link(name = "windows")]
6680         extern "system" {
6681             fn DhcpGetClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u32;
6682         }
6683         ::std::mem::transmute(DhcpGetClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6684     }
6685     #[cfg(not(windows))]
6686     unimplemented!("Unsupported target OS");
6687 }
6688 #[cfg(feature = "Win32_Foundation")]
6689 #[inline]
DhcpGetClientOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u326690 pub unsafe fn DhcpGetClientOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u32 {
6691     #[cfg(windows)]
6692     {
6693         #[link(name = "windows")]
6694         extern "system" {
6695             fn DhcpGetClientOptions(serveripaddress: super::super::Foundation::PWSTR, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u32;
6696         }
6697         ::std::mem::transmute(DhcpGetClientOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(clientipaddress), ::std::mem::transmute(clientsubnetmask), ::std::mem::transmute(clientoptions)))
6698     }
6699     #[cfg(not(windows))]
6700     unimplemented!("Unsupported target OS");
6701 }
6702 #[cfg(feature = "Win32_Foundation")]
6703 #[inline]
DhcpGetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u326704 pub unsafe fn DhcpGetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u32 {
6705     #[cfg(windows)]
6706     {
6707         #[link(name = "windows")]
6708         extern "system" {
6709             fn DhcpGetFilterV4(serveripaddress: super::super::Foundation::PWSTR, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u32;
6710         }
6711         ::std::mem::transmute(DhcpGetFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(globalfilterinfo)))
6712     }
6713     #[cfg(not(windows))]
6714     unimplemented!("Unsupported target OS");
6715 }
6716 #[cfg(feature = "Win32_Foundation")]
6717 #[inline]
DhcpGetMibInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO) -> u326718 pub unsafe fn DhcpGetMibInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO) -> u32 {
6719     #[cfg(windows)]
6720     {
6721         #[link(name = "windows")]
6722         extern "system" {
6723             fn DhcpGetMibInfo(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO) -> u32;
6724         }
6725         ::std::mem::transmute(DhcpGetMibInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6726     }
6727     #[cfg(not(windows))]
6728     unimplemented!("Unsupported target OS");
6729 }
6730 #[cfg(feature = "Win32_Foundation")]
6731 #[inline]
DhcpGetMibInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u326732 pub unsafe fn DhcpGetMibInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u32 {
6733     #[cfg(windows)]
6734     {
6735         #[link(name = "windows")]
6736         extern "system" {
6737             fn DhcpGetMibInfoV5(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u32;
6738         }
6739         ::std::mem::transmute(DhcpGetMibInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6740     }
6741     #[cfg(not(windows))]
6742     unimplemented!("Unsupported target OS");
6743 }
6744 #[cfg(feature = "Win32_Foundation")]
6745 #[inline]
DhcpGetMibInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u326746 pub unsafe fn DhcpGetMibInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u32 {
6747     #[cfg(windows)]
6748     {
6749         #[link(name = "windows")]
6750         extern "system" {
6751             fn DhcpGetMibInfoV6(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u32;
6752         }
6753         ::std::mem::transmute(DhcpGetMibInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6754     }
6755     #[cfg(not(windows))]
6756     unimplemented!("Unsupported target OS");
6757 }
6758 #[cfg(feature = "Win32_Foundation")]
6759 #[inline]
DhcpGetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u326760 pub unsafe fn DhcpGetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6761     #[cfg(windows)]
6762     {
6763         #[link(name = "windows")]
6764         extern "system" {
6765             fn DhcpGetOptionInfo(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6766         }
6767         ::std::mem::transmute(DhcpGetOptionInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
6768     }
6769     #[cfg(not(windows))]
6770     unimplemented!("Unsupported target OS");
6771 }
6772 #[cfg(feature = "Win32_Foundation")]
6773 #[inline]
DhcpGetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u326774 pub unsafe fn DhcpGetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6775     #[cfg(windows)]
6776     {
6777         #[link(name = "windows")]
6778         extern "system" {
6779             fn DhcpGetOptionInfoV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6780         }
6781         ::std::mem::transmute(DhcpGetOptionInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
6782     }
6783     #[cfg(not(windows))]
6784     unimplemented!("Unsupported target OS");
6785 }
6786 #[cfg(feature = "Win32_Foundation")]
6787 #[inline]
DhcpGetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u326788 pub unsafe fn DhcpGetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6789     #[cfg(windows)]
6790     {
6791         #[link(name = "windows")]
6792         extern "system" {
6793             fn DhcpGetOptionInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6794         }
6795         ::std::mem::transmute(DhcpGetOptionInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
6796     }
6797     #[cfg(not(windows))]
6798     unimplemented!("Unsupported target OS");
6799 }
6800 #[cfg(feature = "Win32_Foundation")]
6801 #[inline]
DhcpGetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326802 pub unsafe fn DhcpGetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6803     #[cfg(windows)]
6804     {
6805         #[link(name = "windows")]
6806         extern "system" {
6807             fn DhcpGetOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6808         }
6809         ::std::mem::transmute(DhcpGetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6810     }
6811     #[cfg(not(windows))]
6812     unimplemented!("Unsupported target OS");
6813 }
6814 #[cfg(feature = "Win32_Foundation")]
6815 #[inline]
DhcpGetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326816 pub unsafe fn DhcpGetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6817     #[cfg(windows)]
6818     {
6819         #[link(name = "windows")]
6820         extern "system" {
6821             fn DhcpGetOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6822         }
6823         ::std::mem::transmute(DhcpGetOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6824     }
6825     #[cfg(not(windows))]
6826     unimplemented!("Unsupported target OS");
6827 }
6828 #[cfg(feature = "Win32_Foundation")]
6829 #[inline]
DhcpGetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326830 pub unsafe fn DhcpGetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6831     #[cfg(windows)]
6832     {
6833         #[link(name = "windows")]
6834         extern "system" {
6835             fn DhcpGetOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6836         }
6837         ::std::mem::transmute(DhcpGetOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6838     }
6839     #[cfg(not(windows))]
6840     unimplemented!("Unsupported target OS");
6841 }
6842 #[cfg(feature = "Win32_Foundation")]
6843 #[inline]
DhcpGetOriginalSubnetMask<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(sadaptername: Param0, dwsubnetmask: *mut u32) -> u326844 pub unsafe fn DhcpGetOriginalSubnetMask<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(sadaptername: Param0, dwsubnetmask: *mut u32) -> u32 {
6845     #[cfg(windows)]
6846     {
6847         #[link(name = "windows")]
6848         extern "system" {
6849             fn DhcpGetOriginalSubnetMask(sadaptername: super::super::Foundation::PWSTR, dwsubnetmask: *mut u32) -> u32;
6850         }
6851         ::std::mem::transmute(DhcpGetOriginalSubnetMask(sadaptername.into_param().abi(), ::std::mem::transmute(dwsubnetmask)))
6852     }
6853     #[cfg(not(windows))]
6854     unimplemented!("Unsupported target OS");
6855 }
6856 #[cfg(feature = "Win32_Foundation")]
6857 #[inline]
DhcpGetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u326858 pub unsafe fn DhcpGetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u32 {
6859     #[cfg(windows)]
6860     {
6861         #[link(name = "windows")]
6862         extern "system" {
6863             fn DhcpGetServerBindingInfo(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u32;
6864         }
6865         ::std::mem::transmute(DhcpGetServerBindingInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementsinfo)))
6866     }
6867     #[cfg(not(windows))]
6868     unimplemented!("Unsupported target OS");
6869 }
6870 #[cfg(feature = "Win32_Foundation")]
6871 #[inline]
DhcpGetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u326872 pub unsafe fn DhcpGetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32 {
6873     #[cfg(windows)]
6874     {
6875         #[link(name = "windows")]
6876         extern "system" {
6877             fn DhcpGetServerBindingInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32;
6878         }
6879         ::std::mem::transmute(DhcpGetServerBindingInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementsinfo)))
6880     }
6881     #[cfg(not(windows))]
6882     unimplemented!("Unsupported target OS");
6883 }
6884 #[cfg(feature = "Win32_Foundation")]
6885 #[inline]
DhcpGetServerSpecificStrings<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u326886 pub unsafe fn DhcpGetServerSpecificStrings<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u32 {
6887     #[cfg(windows)]
6888     {
6889         #[link(name = "windows")]
6890         extern "system" {
6891             fn DhcpGetServerSpecificStrings(serveripaddress: super::super::Foundation::PWSTR, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u32;
6892         }
6893         ::std::mem::transmute(DhcpGetServerSpecificStrings(serveripaddress.into_param().abi(), ::std::mem::transmute(serverspecificstrings)))
6894     }
6895     #[cfg(not(windows))]
6896     unimplemented!("Unsupported target OS");
6897 }
6898 #[cfg(feature = "Win32_Foundation")]
6899 #[inline]
DhcpGetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u326900 pub unsafe fn DhcpGetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u32 {
6901     #[cfg(windows)]
6902     {
6903         #[link(name = "windows")]
6904         extern "system" {
6905             fn DhcpGetSubnetDelayOffer(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u32;
6906         }
6907         ::std::mem::transmute(DhcpGetSubnetDelayOffer(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(timedelayinmilliseconds)))
6908     }
6909     #[cfg(not(windows))]
6910     unimplemented!("Unsupported target OS");
6911 }
6912 #[cfg(feature = "Win32_Foundation")]
6913 #[inline]
DhcpGetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u326914 pub unsafe fn DhcpGetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u32 {
6915     #[cfg(windows)]
6916     {
6917         #[link(name = "windows")]
6918         extern "system" {
6919             fn DhcpGetSubnetInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u32;
6920         }
6921         ::std::mem::transmute(DhcpGetSubnetInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
6922     }
6923     #[cfg(not(windows))]
6924     unimplemented!("Unsupported target OS");
6925 }
6926 #[cfg(feature = "Win32_Foundation")]
6927 #[inline]
DhcpGetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u326928 pub unsafe fn DhcpGetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u32 {
6929     #[cfg(windows)]
6930     {
6931         #[link(name = "windows")]
6932         extern "system" {
6933             fn DhcpGetSubnetInfoV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u32;
6934         }
6935         ::std::mem::transmute(DhcpGetSubnetInfoV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
6936     }
6937     #[cfg(not(windows))]
6938     unimplemented!("Unsupported target OS");
6939 }
6940 #[cfg(feature = "Win32_Foundation")]
6941 #[inline]
DhcpGetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u326942 pub unsafe fn DhcpGetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u32 {
6943     #[cfg(windows)]
6944     {
6945         #[link(name = "windows")]
6946         extern "system" {
6947             fn DhcpGetSubnetInfoVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u32;
6948         }
6949         ::std::mem::transmute(DhcpGetSubnetInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
6950     }
6951     #[cfg(not(windows))]
6952     unimplemented!("Unsupported target OS");
6953 }
6954 #[cfg(feature = "Win32_Foundation")]
6955 #[inline]
DhcpGetSuperScopeInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u326956 pub unsafe fn DhcpGetSuperScopeInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u32 {
6957     #[cfg(windows)]
6958     {
6959         #[link(name = "windows")]
6960         extern "system" {
6961             fn DhcpGetSuperScopeInfoV4(serveripaddress: super::super::Foundation::PWSTR, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u32;
6962         }
6963         ::std::mem::transmute(DhcpGetSuperScopeInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(superscopetable)))
6964     }
6965     #[cfg(not(windows))]
6966     unimplemented!("Unsupported target OS");
6967 }
6968 #[inline]
DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u326969 pub unsafe fn DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u32 {
6970     #[cfg(windows)]
6971     {
6972         #[link(name = "windows")]
6973         extern "system" {
6974             fn DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u32;
6975         }
6976         ::std::mem::transmute(DhcpGetThreadOptions(::std::mem::transmute(pflags), ::std::mem::transmute(reserved)))
6977     }
6978     #[cfg(not(windows))]
6979     unimplemented!("Unsupported target OS");
6980 }
6981 #[cfg(feature = "Win32_Foundation")]
6982 #[inline]
DhcpGetVersion<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, majorversion: *mut u32, minorversion: *mut u32) -> u326983 pub unsafe fn DhcpGetVersion<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, majorversion: *mut u32, minorversion: *mut u32) -> u32 {
6984     #[cfg(windows)]
6985     {
6986         #[link(name = "windows")]
6987         extern "system" {
6988             fn DhcpGetVersion(serveripaddress: super::super::Foundation::PWSTR, majorversion: *mut u32, minorversion: *mut u32) -> u32;
6989         }
6990         ::std::mem::transmute(DhcpGetVersion(serveripaddress.into_param().abi(), ::std::mem::transmute(majorversion), ::std::mem::transmute(minorversion)))
6991     }
6992     #[cfg(not(windows))]
6993     unimplemented!("Unsupported target OS");
6994 }
6995 #[cfg(feature = "Win32_Foundation")]
6996 #[inline]
DhcpHlprAddV4PolicyCondition<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: Param5, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u326997 pub unsafe fn DhcpHlprAddV4PolicyCondition<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: Param5, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u32 {
6998     #[cfg(windows)]
6999     {
7000         #[link(name = "windows")]
7001         extern "system" {
7002             fn DhcpHlprAddV4PolicyCondition(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: super::super::Foundation::PWSTR, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u32;
7003         }
7004         ::std::mem::transmute(DhcpHlprAddV4PolicyCondition(
7005             ::std::mem::transmute(policy),
7006             ::std::mem::transmute(parentexpr),
7007             ::std::mem::transmute(r#type),
7008             ::std::mem::transmute(optionid),
7009             ::std::mem::transmute(suboptionid),
7010             vendorname.into_param().abi(),
7011             ::std::mem::transmute(operator),
7012             ::std::mem::transmute(value),
7013             ::std::mem::transmute(valuelength),
7014             ::std::mem::transmute(conditionindex),
7015         ))
7016     }
7017     #[cfg(not(windows))]
7018     unimplemented!("Unsupported target OS");
7019 }
7020 #[cfg(feature = "Win32_Foundation")]
7021 #[inline]
DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u327022 pub unsafe fn DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u32 {
7023     #[cfg(windows)]
7024     {
7025         #[link(name = "windows")]
7026         extern "system" {
7027             fn DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u32;
7028         }
7029         ::std::mem::transmute(DhcpHlprAddV4PolicyExpr(::std::mem::transmute(policy), ::std::mem::transmute(parentexpr), ::std::mem::transmute(operator), ::std::mem::transmute(exprindex)))
7030     }
7031     #[cfg(not(windows))]
7032     unimplemented!("Unsupported target OS");
7033 }
7034 #[cfg(feature = "Win32_Foundation")]
7035 #[inline]
DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u327036 pub unsafe fn DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u32 {
7037     #[cfg(windows)]
7038     {
7039         #[link(name = "windows")]
7040         extern "system" {
7041             fn DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u32;
7042         }
7043         ::std::mem::transmute(DhcpHlprAddV4PolicyRange(::std::mem::transmute(policy), ::std::mem::transmute(range)))
7044     }
7045     #[cfg(not(windows))]
7046     unimplemented!("Unsupported target OS");
7047 }
7048 #[cfg(feature = "Win32_Foundation")]
7049 #[inline]
DhcpHlprCreateV4Policy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( policyname: Param0, fglobalpolicy: Param1, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: Param5, enabled: Param6, policy: *mut *mut DHCP_POLICY, ) -> u327050 pub unsafe fn DhcpHlprCreateV4Policy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
7051     policyname: Param0,
7052     fglobalpolicy: Param1,
7053     subnet: u32,
7054     processingorder: u32,
7055     rootoperator: DHCP_POL_LOGIC_OPER,
7056     description: Param5,
7057     enabled: Param6,
7058     policy: *mut *mut DHCP_POLICY,
7059 ) -> u32 {
7060     #[cfg(windows)]
7061     {
7062         #[link(name = "windows")]
7063         extern "system" {
7064             fn DhcpHlprCreateV4Policy(policyname: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: super::super::Foundation::PWSTR, enabled: super::super::Foundation::BOOL, policy: *mut *mut DHCP_POLICY) -> u32;
7065         }
7066         ::std::mem::transmute(DhcpHlprCreateV4Policy(policyname.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnet), ::std::mem::transmute(processingorder), ::std::mem::transmute(rootoperator), description.into_param().abi(), enabled.into_param().abi(), ::std::mem::transmute(policy)))
7067     }
7068     #[cfg(not(windows))]
7069     unimplemented!("Unsupported target OS");
7070 }
7071 #[cfg(feature = "Win32_Foundation")]
7072 #[inline]
DhcpHlprCreateV4PolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( policyname: Param0, fglobalpolicy: Param1, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: Param5, enabled: Param6, policy: *mut *mut DHCP_POLICY_EX, ) -> u327073 pub unsafe fn DhcpHlprCreateV4PolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
7074     policyname: Param0,
7075     fglobalpolicy: Param1,
7076     subnet: u32,
7077     processingorder: u32,
7078     rootoperator: DHCP_POL_LOGIC_OPER,
7079     description: Param5,
7080     enabled: Param6,
7081     policy: *mut *mut DHCP_POLICY_EX,
7082 ) -> u32 {
7083     #[cfg(windows)]
7084     {
7085         #[link(name = "windows")]
7086         extern "system" {
7087             fn DhcpHlprCreateV4PolicyEx(policyname: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: super::super::Foundation::PWSTR, enabled: super::super::Foundation::BOOL, policy: *mut *mut DHCP_POLICY_EX) -> u32;
7088         }
7089         ::std::mem::transmute(DhcpHlprCreateV4PolicyEx(policyname.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnet), ::std::mem::transmute(processingorder), ::std::mem::transmute(rootoperator), description.into_param().abi(), enabled.into_param().abi(), ::std::mem::transmute(policy)))
7090     }
7091     #[cfg(not(windows))]
7092     unimplemented!("Unsupported target OS");
7093 }
7094 #[cfg(feature = "Win32_Foundation")]
7095 #[inline]
DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY7096 pub unsafe fn DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY {
7097     #[cfg(windows)]
7098     {
7099         #[link(name = "windows")]
7100         extern "system" {
7101             fn DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY;
7102         }
7103         ::std::mem::transmute(DhcpHlprFindV4DhcpProperty(::std::mem::transmute(propertyarray), ::std::mem::transmute(id), ::std::mem::transmute(r#type)))
7104     }
7105     #[cfg(not(windows))]
7106     unimplemented!("Unsupported target OS");
7107 }
7108 #[cfg(feature = "Win32_Foundation")]
7109 #[inline]
DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY)7110 pub unsafe fn DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY) {
7111     #[cfg(windows)]
7112     {
7113         #[link(name = "windows")]
7114         extern "system" {
7115             fn DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY);
7116         }
7117         ::std::mem::transmute(DhcpHlprFreeV4DhcpProperty(::std::mem::transmute(property)))
7118     }
7119     #[cfg(not(windows))]
7120     unimplemented!("Unsupported target OS");
7121 }
7122 #[cfg(feature = "Win32_Foundation")]
7123 #[inline]
DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY)7124 pub unsafe fn DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY) {
7125     #[cfg(windows)]
7126     {
7127         #[link(name = "windows")]
7128         extern "system" {
7129             fn DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY);
7130         }
7131         ::std::mem::transmute(DhcpHlprFreeV4DhcpPropertyArray(::std::mem::transmute(propertyarray)))
7132     }
7133     #[cfg(not(windows))]
7134     unimplemented!("Unsupported target OS");
7135 }
7136 #[cfg(feature = "Win32_Foundation")]
7137 #[inline]
DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY)7138 pub unsafe fn DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY) {
7139     #[cfg(windows)]
7140     {
7141         #[link(name = "windows")]
7142         extern "system" {
7143             fn DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY);
7144         }
7145         ::std::mem::transmute(DhcpHlprFreeV4Policy(::std::mem::transmute(policy)))
7146     }
7147     #[cfg(not(windows))]
7148     unimplemented!("Unsupported target OS");
7149 }
7150 #[cfg(feature = "Win32_Foundation")]
7151 #[inline]
DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY)7152 pub unsafe fn DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY) {
7153     #[cfg(windows)]
7154     {
7155         #[link(name = "windows")]
7156         extern "system" {
7157             fn DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY);
7158         }
7159         ::std::mem::transmute(DhcpHlprFreeV4PolicyArray(::std::mem::transmute(policyarray)))
7160     }
7161     #[cfg(not(windows))]
7162     unimplemented!("Unsupported target OS");
7163 }
7164 #[cfg(feature = "Win32_Foundation")]
7165 #[inline]
DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX)7166 pub unsafe fn DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX) {
7167     #[cfg(windows)]
7168     {
7169         #[link(name = "windows")]
7170         extern "system" {
7171             fn DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX);
7172         }
7173         ::std::mem::transmute(DhcpHlprFreeV4PolicyEx(::std::mem::transmute(policyex)))
7174     }
7175     #[cfg(not(windows))]
7176     unimplemented!("Unsupported target OS");
7177 }
7178 #[cfg(feature = "Win32_Foundation")]
7179 #[inline]
DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY)7180 pub unsafe fn DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY) {
7181     #[cfg(windows)]
7182     {
7183         #[link(name = "windows")]
7184         extern "system" {
7185             fn DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY);
7186         }
7187         ::std::mem::transmute(DhcpHlprFreeV4PolicyExArray(::std::mem::transmute(policyexarray)))
7188     }
7189     #[cfg(not(windows))]
7190     unimplemented!("Unsupported target OS");
7191 }
7192 #[cfg(feature = "Win32_Foundation")]
7193 #[inline]
DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL7194 pub unsafe fn DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL {
7195     #[cfg(windows)]
7196     {
7197         #[link(name = "windows")]
7198         extern "system" {
7199             fn DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL;
7200         }
7201         ::std::mem::transmute(DhcpHlprIsV4PolicySingleUC(::std::mem::transmute(policy)))
7202     }
7203     #[cfg(not(windows))]
7204     unimplemented!("Unsupported target OS");
7205 }
7206 #[cfg(feature = "Win32_Foundation")]
7207 #[inline]
DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u327208 pub unsafe fn DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u32 {
7209     #[cfg(windows)]
7210     {
7211         #[link(name = "windows")]
7212         extern "system" {
7213             fn DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u32;
7214         }
7215         ::std::mem::transmute(DhcpHlprIsV4PolicyValid(::std::mem::transmute(ppolicy)))
7216     }
7217     #[cfg(not(windows))]
7218     unimplemented!("Unsupported target OS");
7219 }
7220 #[cfg(feature = "Win32_Foundation")]
7221 #[inline]
DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL7222 pub unsafe fn DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL {
7223     #[cfg(windows)]
7224     {
7225         #[link(name = "windows")]
7226         extern "system" {
7227             fn DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL;
7228         }
7229         ::std::mem::transmute(DhcpHlprIsV4PolicyWellFormed(::std::mem::transmute(ppolicy)))
7230     }
7231     #[cfg(not(windows))]
7232     unimplemented!("Unsupported target OS");
7233 }
7234 #[cfg(feature = "Win32_Foundation")]
7235 #[inline]
DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u327236 pub unsafe fn DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u32 {
7237     #[cfg(windows)]
7238     {
7239         #[link(name = "windows")]
7240         extern "system" {
7241             fn DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u32;
7242         }
7243         ::std::mem::transmute(DhcpHlprModifyV4PolicyExpr(::std::mem::transmute(policy), ::std::mem::transmute(operator)))
7244     }
7245     #[cfg(not(windows))]
7246     unimplemented!("Unsupported target OS");
7247 }
7248 #[cfg(feature = "Win32_Foundation")]
7249 #[inline]
DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u327250 pub unsafe fn DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u32 {
7251     #[cfg(windows)]
7252     {
7253         #[link(name = "windows")]
7254         extern "system" {
7255             fn DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u32;
7256         }
7257         ::std::mem::transmute(DhcpHlprResetV4PolicyExpr(::std::mem::transmute(policy)))
7258     }
7259     #[cfg(not(windows))]
7260     unimplemented!("Unsupported target OS");
7261 }
7262 #[cfg(feature = "Win32_Foundation")]
7263 #[inline]
DhcpModifyClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u327264 pub unsafe fn DhcpModifyClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32 {
7265     #[cfg(windows)]
7266     {
7267         #[link(name = "windows")]
7268         extern "system" {
7269             fn DhcpModifyClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32;
7270         }
7271         ::std::mem::transmute(DhcpModifyClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
7272     }
7273     #[cfg(not(windows))]
7274     unimplemented!("Unsupported target OS");
7275 }
7276 #[cfg(feature = "Win32_Foundation")]
7277 #[inline]
DhcpModifyClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u327278 pub unsafe fn DhcpModifyClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32 {
7279     #[cfg(windows)]
7280     {
7281         #[link(name = "windows")]
7282         extern "system" {
7283             fn DhcpModifyClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32;
7284         }
7285         ::std::mem::transmute(DhcpModifyClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
7286     }
7287     #[cfg(not(windows))]
7288     unimplemented!("Unsupported target OS");
7289 }
7290 #[cfg(feature = "Win32_Foundation")]
7291 #[inline]
DhcpRegisterParamChange<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, params: Param4, handle: *mut ::std::ffi::c_void) -> u327292 pub unsafe fn DhcpRegisterParamChange<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, params: Param4, handle: *mut ::std::ffi::c_void) -> u32 {
7293     #[cfg(windows)]
7294     {
7295         #[link(name = "windows")]
7296         extern "system" {
7297             fn DhcpRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPCAPI_CLASSID, params: DHCPCAPI_PARAMS_ARRAY, handle: *mut ::std::ffi::c_void) -> u32;
7298         }
7299         ::std::mem::transmute(DhcpRegisterParamChange(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), params.into_param().abi(), ::std::mem::transmute(handle)))
7300     }
7301     #[cfg(not(windows))]
7302     unimplemented!("Unsupported target OS");
7303 }
7304 #[inline]
DhcpRemoveDNSRegistrations() -> u327305 pub unsafe fn DhcpRemoveDNSRegistrations() -> u32 {
7306     #[cfg(windows)]
7307     {
7308         #[link(name = "windows")]
7309         extern "system" {
7310             fn DhcpRemoveDNSRegistrations() -> u32;
7311         }
7312         ::std::mem::transmute(DhcpRemoveDNSRegistrations())
7313     }
7314     #[cfg(not(windows))]
7315     unimplemented!("Unsupported target OS");
7316 }
7317 #[cfg(feature = "Win32_Foundation")]
7318 #[inline]
DhcpRemoveOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32) -> u327319 pub unsafe fn DhcpRemoveOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32) -> u32 {
7320     #[cfg(windows)]
7321     {
7322         #[link(name = "windows")]
7323         extern "system" {
7324             fn DhcpRemoveOption(serveripaddress: super::super::Foundation::PWSTR, optionid: u32) -> u32;
7325         }
7326         ::std::mem::transmute(DhcpRemoveOption(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid)))
7327     }
7328     #[cfg(not(windows))]
7329     unimplemented!("Unsupported target OS");
7330 }
7331 #[cfg(feature = "Win32_Foundation")]
7332 #[inline]
DhcpRemoveOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u327333 pub unsafe fn DhcpRemoveOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u32 {
7334     #[cfg(windows)]
7335     {
7336         #[link(name = "windows")]
7337         extern "system" {
7338             fn DhcpRemoveOptionV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR) -> u32;
7339         }
7340         ::std::mem::transmute(DhcpRemoveOptionV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi()))
7341     }
7342     #[cfg(not(windows))]
7343     unimplemented!("Unsupported target OS");
7344 }
7345 #[cfg(feature = "Win32_Foundation")]
7346 #[inline]
DhcpRemoveOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u327347 pub unsafe fn DhcpRemoveOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u32 {
7348     #[cfg(windows)]
7349     {
7350         #[link(name = "windows")]
7351         extern "system" {
7352             fn DhcpRemoveOptionV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR) -> u32;
7353         }
7354         ::std::mem::transmute(DhcpRemoveOptionV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi()))
7355     }
7356     #[cfg(not(windows))]
7357     unimplemented!("Unsupported target OS");
7358 }
7359 #[cfg(feature = "Win32_Foundation")]
7360 #[inline]
DhcpRemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u327361 pub unsafe fn DhcpRemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u32 {
7362     #[cfg(windows)]
7363     {
7364         #[link(name = "windows")]
7365         extern "system" {
7366             fn DhcpRemoveOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u32;
7367         }
7368         ::std::mem::transmute(DhcpRemoveOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo)))
7369     }
7370     #[cfg(not(windows))]
7371     unimplemented!("Unsupported target OS");
7372 }
7373 #[cfg(feature = "Win32_Foundation")]
7374 #[inline]
DhcpRemoveOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u327375 pub unsafe fn DhcpRemoveOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32 {
7376     #[cfg(windows)]
7377     {
7378         #[link(name = "windows")]
7379         extern "system" {
7380             fn DhcpRemoveOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32;
7381         }
7382         ::std::mem::transmute(DhcpRemoveOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
7383     }
7384     #[cfg(not(windows))]
7385     unimplemented!("Unsupported target OS");
7386 }
7387 #[cfg(feature = "Win32_Foundation")]
7388 #[inline]
DhcpRemoveOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u327389 pub unsafe fn DhcpRemoveOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u32 {
7390     #[cfg(windows)]
7391     {
7392         #[link(name = "windows")]
7393         extern "system" {
7394             fn DhcpRemoveOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u32;
7395         }
7396         ::std::mem::transmute(DhcpRemoveOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
7397     }
7398     #[cfg(not(windows))]
7399     unimplemented!("Unsupported target OS");
7400 }
7401 #[cfg(feature = "Win32_Foundation")]
7402 #[inline]
DhcpRemoveSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u327403 pub unsafe fn DhcpRemoveSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u32 {
7404     #[cfg(windows)]
7405     {
7406         #[link(name = "windows")]
7407         extern "system" {
7408             fn DhcpRemoveSubnetElement(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u32;
7409         }
7410         ::std::mem::transmute(DhcpRemoveSubnetElement(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7411     }
7412     #[cfg(not(windows))]
7413     unimplemented!("Unsupported target OS");
7414 }
7415 #[cfg(feature = "Win32_Foundation")]
7416 #[inline]
DhcpRemoveSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u327417 pub unsafe fn DhcpRemoveSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u32 {
7418     #[cfg(windows)]
7419     {
7420         #[link(name = "windows")]
7421         extern "system" {
7422             fn DhcpRemoveSubnetElementV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u32;
7423         }
7424         ::std::mem::transmute(DhcpRemoveSubnetElementV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7425     }
7426     #[cfg(not(windows))]
7427     unimplemented!("Unsupported target OS");
7428 }
7429 #[cfg(feature = "Win32_Foundation")]
7430 #[inline]
DhcpRemoveSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u327431 pub unsafe fn DhcpRemoveSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u32 {
7432     #[cfg(windows)]
7433     {
7434         #[link(name = "windows")]
7435         extern "system" {
7436             fn DhcpRemoveSubnetElementV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u32;
7437         }
7438         ::std::mem::transmute(DhcpRemoveSubnetElementV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7439     }
7440     #[cfg(not(windows))]
7441     unimplemented!("Unsupported target OS");
7442 }
7443 #[cfg(feature = "Win32_Foundation")]
7444 #[inline]
DhcpRemoveSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u327445 pub unsafe fn DhcpRemoveSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u32 {
7446     #[cfg(windows)]
7447     {
7448         #[link(name = "windows")]
7449         extern "system" {
7450             fn DhcpRemoveSubnetElementV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u32;
7451         }
7452         ::std::mem::transmute(DhcpRemoveSubnetElementV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7453     }
7454     #[cfg(not(windows))]
7455     unimplemented!("Unsupported target OS");
7456 }
7457 #[cfg(feature = "Win32_Foundation")]
7458 #[inline]
DhcpRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param5: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, sendparams: Param4, recdparams: Param5, buffer: *mut u8, psize: *mut u32, requestidstr: Param8, ) -> u327459 pub unsafe fn DhcpRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param5: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
7460     flags: u32,
7461     reserved: *mut ::std::ffi::c_void,
7462     adaptername: Param2,
7463     classid: *mut DHCPCAPI_CLASSID,
7464     sendparams: Param4,
7465     recdparams: Param5,
7466     buffer: *mut u8,
7467     psize: *mut u32,
7468     requestidstr: Param8,
7469 ) -> u32 {
7470     #[cfg(windows)]
7471     {
7472         #[link(name = "windows")]
7473         extern "system" {
7474             fn DhcpRequestParams(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPCAPI_CLASSID, sendparams: DHCPCAPI_PARAMS_ARRAY, recdparams: DHCPCAPI_PARAMS_ARRAY, buffer: *mut u8, psize: *mut u32, requestidstr: super::super::Foundation::PWSTR) -> u32;
7475         }
7476         ::std::mem::transmute(DhcpRequestParams(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), sendparams.into_param().abi(), recdparams.into_param().abi(), ::std::mem::transmute(buffer), ::std::mem::transmute(psize), requestidstr.into_param().abi()))
7477     }
7478     #[cfg(not(windows))]
7479     unimplemented!("Unsupported target OS");
7480 }
7481 #[inline]
DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void)7482 pub unsafe fn DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void) {
7483     #[cfg(windows)]
7484     {
7485         #[link(name = "windows")]
7486         extern "system" {
7487             fn DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void);
7488         }
7489         ::std::mem::transmute(DhcpRpcFreeMemory(::std::mem::transmute(bufferpointer)))
7490     }
7491     #[cfg(not(windows))]
7492     unimplemented!("Unsupported target OS");
7493 }
7494 #[cfg(feature = "Win32_Foundation")]
7495 #[inline]
DhcpScanDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u327496 pub unsafe fn DhcpScanDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u32 {
7497     #[cfg(windows)]
7498     {
7499         #[link(name = "windows")]
7500         extern "system" {
7501             fn DhcpScanDatabase(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u32;
7502         }
7503         ::std::mem::transmute(DhcpScanDatabase(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(fixflag), ::std::mem::transmute(scanlist)))
7504     }
7505     #[cfg(not(windows))]
7506     unimplemented!("Unsupported target OS");
7507 }
7508 #[cfg(feature = "Win32_Foundation")]
7509 #[inline]
DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ)7510 pub unsafe fn DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) {
7511     #[cfg(windows)]
7512     {
7513         #[link(name = "windows")]
7514         extern "system" {
7515             fn DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ);
7516         }
7517         ::std::mem::transmute(DhcpServerAuditlogParamsFree(::std::mem::transmute(configinfo)))
7518     }
7519     #[cfg(not(windows))]
7520     unimplemented!("Unsupported target OS");
7521 }
7522 #[cfg(feature = "Win32_Foundation")]
7523 #[inline]
DhcpServerBackupDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u327524 pub unsafe fn DhcpServerBackupDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u32 {
7525     #[cfg(windows)]
7526     {
7527         #[link(name = "windows")]
7528         extern "system" {
7529             fn DhcpServerBackupDatabase(serveripaddress: super::super::Foundation::PWSTR, path: super::super::Foundation::PWSTR) -> u32;
7530         }
7531         ::std::mem::transmute(DhcpServerBackupDatabase(serveripaddress.into_param().abi(), path.into_param().abi()))
7532     }
7533     #[cfg(not(windows))]
7534     unimplemented!("Unsupported target OS");
7535 }
7536 #[cfg(feature = "Win32_Foundation")]
7537 #[inline]
DhcpServerGetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u327538 pub unsafe fn DhcpServerGetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u32 {
7539     #[cfg(windows)]
7540     {
7541         #[link(name = "windows")]
7542         extern "system" {
7543             fn DhcpServerGetConfig(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u32;
7544         }
7545         ::std::mem::transmute(DhcpServerGetConfig(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7546     }
7547     #[cfg(not(windows))]
7548     unimplemented!("Unsupported target OS");
7549 }
7550 #[cfg(feature = "Win32_Foundation")]
7551 #[inline]
DhcpServerGetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u327552 pub unsafe fn DhcpServerGetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32 {
7553     #[cfg(windows)]
7554     {
7555         #[link(name = "windows")]
7556         extern "system" {
7557             fn DhcpServerGetConfigV4(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32;
7558         }
7559         ::std::mem::transmute(DhcpServerGetConfigV4(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7560     }
7561     #[cfg(not(windows))]
7562     unimplemented!("Unsupported target OS");
7563 }
7564 #[cfg(feature = "Win32_Foundation")]
7565 #[inline]
DhcpServerGetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u327566 pub unsafe fn DhcpServerGetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32 {
7567     #[cfg(windows)]
7568     {
7569         #[link(name = "windows")]
7570         extern "system" {
7571             fn DhcpServerGetConfigV6(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32;
7572         }
7573         ::std::mem::transmute(DhcpServerGetConfigV6(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(configinfo)))
7574     }
7575     #[cfg(not(windows))]
7576     unimplemented!("Unsupported target OS");
7577 }
7578 #[cfg(feature = "Win32_Foundation")]
7579 #[inline]
DhcpServerGetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u327580 pub unsafe fn DhcpServerGetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32 {
7581     #[cfg(windows)]
7582     {
7583         #[link(name = "windows")]
7584         extern "system" {
7585             fn DhcpServerGetConfigVQ(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32;
7586         }
7587         ::std::mem::transmute(DhcpServerGetConfigVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7588     }
7589     #[cfg(not(windows))]
7590     unimplemented!("Unsupported target OS");
7591 }
7592 #[cfg(feature = "Win32_Foundation")]
7593 #[inline]
DhcpServerQueryAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u327594 pub unsafe fn DhcpServerQueryAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u32 {
7595     #[cfg(windows)]
7596     {
7597         #[link(name = "windows")]
7598         extern "system" {
7599             fn DhcpServerQueryAttribute(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u32;
7600         }
7601         ::std::mem::transmute(DhcpServerQueryAttribute(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(dhcpattribid), ::std::mem::transmute(pdhcpattrib)))
7602     }
7603     #[cfg(not(windows))]
7604     unimplemented!("Unsupported target OS");
7605 }
7606 #[cfg(feature = "Win32_Foundation")]
7607 #[inline]
DhcpServerQueryAttributes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u327608 pub unsafe fn DhcpServerQueryAttributes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u32 {
7609     #[cfg(windows)]
7610     {
7611         #[link(name = "windows")]
7612         extern "system" {
7613             fn DhcpServerQueryAttributes(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u32;
7614         }
7615         ::std::mem::transmute(DhcpServerQueryAttributes(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(dwattribcount), ::std::mem::transmute(pdhcpattribs), ::std::mem::transmute(pdhcpattribarr)))
7616     }
7617     #[cfg(not(windows))]
7618     unimplemented!("Unsupported target OS");
7619 }
7620 #[cfg(feature = "Win32_Foundation")]
7621 #[inline]
DhcpServerQueryDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u327622 pub unsafe fn DhcpServerQueryDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u32 {
7623     #[cfg(windows)]
7624     {
7625         #[link(name = "windows")]
7626         extern "system" {
7627             fn DhcpServerQueryDnsRegCredentials(serveripaddress: super::super::Foundation::PWSTR, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u32;
7628         }
7629         ::std::mem::transmute(DhcpServerQueryDnsRegCredentials(serveripaddress.into_param().abi(), ::std::mem::transmute(unamesize), ::std::mem::transmute(uname), ::std::mem::transmute(domainsize), ::std::mem::transmute(domain)))
7630     }
7631     #[cfg(not(windows))]
7632     unimplemented!("Unsupported target OS");
7633 }
7634 #[cfg(feature = "Win32_Foundation")]
7635 #[inline]
DhcpServerRedoAuthorization<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32) -> u327636 pub unsafe fn DhcpServerRedoAuthorization<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32) -> u32 {
7637     #[cfg(windows)]
7638     {
7639         #[link(name = "windows")]
7640         extern "system" {
7641             fn DhcpServerRedoAuthorization(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32) -> u32;
7642         }
7643         ::std::mem::transmute(DhcpServerRedoAuthorization(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved)))
7644     }
7645     #[cfg(not(windows))]
7646     unimplemented!("Unsupported target OS");
7647 }
7648 #[cfg(feature = "Win32_Foundation")]
7649 #[inline]
DhcpServerRestoreDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u327650 pub unsafe fn DhcpServerRestoreDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u32 {
7651     #[cfg(windows)]
7652     {
7653         #[link(name = "windows")]
7654         extern "system" {
7655             fn DhcpServerRestoreDatabase(serveripaddress: super::super::Foundation::PWSTR, path: super::super::Foundation::PWSTR) -> u32;
7656         }
7657         ::std::mem::transmute(DhcpServerRestoreDatabase(serveripaddress.into_param().abi(), path.into_param().abi()))
7658     }
7659     #[cfg(not(windows))]
7660     unimplemented!("Unsupported target OS");
7661 }
7662 #[cfg(feature = "Win32_Foundation")]
7663 #[inline]
DhcpServerSetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u327664 pub unsafe fn DhcpServerSetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u32 {
7665     #[cfg(windows)]
7666     {
7667         #[link(name = "windows")]
7668         extern "system" {
7669             fn DhcpServerSetConfig(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u32;
7670         }
7671         ::std::mem::transmute(DhcpServerSetConfig(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7672     }
7673     #[cfg(not(windows))]
7674     unimplemented!("Unsupported target OS");
7675 }
7676 #[cfg(feature = "Win32_Foundation")]
7677 #[inline]
DhcpServerSetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u327678 pub unsafe fn DhcpServerSetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32 {
7679     #[cfg(windows)]
7680     {
7681         #[link(name = "windows")]
7682         extern "system" {
7683             fn DhcpServerSetConfigV4(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32;
7684         }
7685         ::std::mem::transmute(DhcpServerSetConfigV4(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7686     }
7687     #[cfg(not(windows))]
7688     unimplemented!("Unsupported target OS");
7689 }
7690 #[cfg(feature = "Win32_Foundation")]
7691 #[inline]
DhcpServerSetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u327692 pub unsafe fn DhcpServerSetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32 {
7693     #[cfg(windows)]
7694     {
7695         #[link(name = "windows")]
7696         extern "system" {
7697             fn DhcpServerSetConfigV6(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32;
7698         }
7699         ::std::mem::transmute(DhcpServerSetConfigV6(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7700     }
7701     #[cfg(not(windows))]
7702     unimplemented!("Unsupported target OS");
7703 }
7704 #[cfg(feature = "Win32_Foundation")]
7705 #[inline]
DhcpServerSetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u327706 pub unsafe fn DhcpServerSetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32 {
7707     #[cfg(windows)]
7708     {
7709         #[link(name = "windows")]
7710         extern "system" {
7711             fn DhcpServerSetConfigVQ(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32;
7712         }
7713         ::std::mem::transmute(DhcpServerSetConfigVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7714     }
7715     #[cfg(not(windows))]
7716     unimplemented!("Unsupported target OS");
7717 }
7718 #[cfg(feature = "Win32_Foundation")]
7719 #[inline]
DhcpServerSetDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u327720 pub unsafe fn DhcpServerSetDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u32 {
7721     #[cfg(windows)]
7722     {
7723         #[link(name = "windows")]
7724         extern "system" {
7725             fn DhcpServerSetDnsRegCredentials(serveripaddress: super::super::Foundation::PWSTR, uname: super::super::Foundation::PWSTR, domain: super::super::Foundation::PWSTR, passwd: super::super::Foundation::PWSTR) -> u32;
7726         }
7727         ::std::mem::transmute(DhcpServerSetDnsRegCredentials(serveripaddress.into_param().abi(), uname.into_param().abi(), domain.into_param().abi(), passwd.into_param().abi()))
7728     }
7729     #[cfg(not(windows))]
7730     unimplemented!("Unsupported target OS");
7731 }
7732 #[cfg(feature = "Win32_Foundation")]
7733 #[inline]
DhcpServerSetDnsRegCredentialsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u327734 pub unsafe fn DhcpServerSetDnsRegCredentialsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u32 {
7735     #[cfg(windows)]
7736     {
7737         #[link(name = "windows")]
7738         extern "system" {
7739             fn DhcpServerSetDnsRegCredentialsV5(serveripaddress: super::super::Foundation::PWSTR, uname: super::super::Foundation::PWSTR, domain: super::super::Foundation::PWSTR, passwd: super::super::Foundation::PWSTR) -> u32;
7740         }
7741         ::std::mem::transmute(DhcpServerSetDnsRegCredentialsV5(serveripaddress.into_param().abi(), uname.into_param().abi(), domain.into_param().abi(), passwd.into_param().abi()))
7742     }
7743     #[cfg(not(windows))]
7744     unimplemented!("Unsupported target OS");
7745 }
7746 #[cfg(feature = "Win32_Foundation")]
7747 #[inline]
DhcpSetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u327748 pub unsafe fn DhcpSetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u32 {
7749     #[cfg(windows)]
7750     {
7751         #[link(name = "windows")]
7752         extern "system" {
7753             fn DhcpSetClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO) -> u32;
7754         }
7755         ::std::mem::transmute(DhcpSetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7756     }
7757     #[cfg(not(windows))]
7758     unimplemented!("Unsupported target OS");
7759 }
7760 #[cfg(feature = "Win32_Foundation")]
7761 #[inline]
DhcpSetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u327762 pub unsafe fn DhcpSetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32 {
7763     #[cfg(windows)]
7764     {
7765         #[link(name = "windows")]
7766         extern "system" {
7767             fn DhcpSetClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32;
7768         }
7769         ::std::mem::transmute(DhcpSetClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7770     }
7771     #[cfg(not(windows))]
7772     unimplemented!("Unsupported target OS");
7773 }
7774 #[cfg(feature = "Win32_Foundation")]
7775 #[inline]
DhcpSetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u327776 pub unsafe fn DhcpSetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32 {
7777     #[cfg(windows)]
7778     {
7779         #[link(name = "windows")]
7780         extern "system" {
7781             fn DhcpSetClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32;
7782         }
7783         ::std::mem::transmute(DhcpSetClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7784     }
7785     #[cfg(not(windows))]
7786     unimplemented!("Unsupported target OS");
7787 }
7788 #[cfg(feature = "Win32_Foundation")]
7789 #[inline]
DhcpSetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u327790 pub unsafe fn DhcpSetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32 {
7791     #[cfg(windows)]
7792     {
7793         #[link(name = "windows")]
7794         extern "system" {
7795             fn DhcpSetClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32;
7796         }
7797         ::std::mem::transmute(DhcpSetClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7798     }
7799     #[cfg(not(windows))]
7800     unimplemented!("Unsupported target OS");
7801 }
7802 #[cfg(feature = "Win32_Foundation")]
7803 #[inline]
DhcpSetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u327804 pub unsafe fn DhcpSetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u32 {
7805     #[cfg(windows)]
7806     {
7807         #[link(name = "windows")]
7808         extern "system" {
7809             fn DhcpSetFilterV4(serveripaddress: super::super::Foundation::PWSTR, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u32;
7810         }
7811         ::std::mem::transmute(DhcpSetFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(globalfilterinfo)))
7812     }
7813     #[cfg(not(windows))]
7814     unimplemented!("Unsupported target OS");
7815 }
7816 #[cfg(feature = "Win32_Foundation")]
7817 #[inline]
DhcpSetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u327818 pub unsafe fn DhcpSetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32 {
7819     #[cfg(windows)]
7820     {
7821         #[link(name = "windows")]
7822         extern "system" {
7823             fn DhcpSetOptionInfo(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32;
7824         }
7825         ::std::mem::transmute(DhcpSetOptionInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
7826     }
7827     #[cfg(not(windows))]
7828     unimplemented!("Unsupported target OS");
7829 }
7830 #[cfg(feature = "Win32_Foundation")]
7831 #[inline]
DhcpSetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u327832 pub unsafe fn DhcpSetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
7833     #[cfg(windows)]
7834     {
7835         #[link(name = "windows")]
7836         extern "system" {
7837             fn DhcpSetOptionInfoV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
7838         }
7839         ::std::mem::transmute(DhcpSetOptionInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
7840     }
7841     #[cfg(not(windows))]
7842     unimplemented!("Unsupported target OS");
7843 }
7844 #[cfg(feature = "Win32_Foundation")]
7845 #[inline]
DhcpSetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u327846 pub unsafe fn DhcpSetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
7847     #[cfg(windows)]
7848     {
7849         #[link(name = "windows")]
7850         extern "system" {
7851             fn DhcpSetOptionInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
7852         }
7853         ::std::mem::transmute(DhcpSetOptionInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
7854     }
7855     #[cfg(not(windows))]
7856     unimplemented!("Unsupported target OS");
7857 }
7858 #[cfg(feature = "Win32_Foundation")]
7859 #[inline]
DhcpSetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u327860 pub unsafe fn DhcpSetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u32 {
7861     #[cfg(windows)]
7862     {
7863         #[link(name = "windows")]
7864         extern "system" {
7865             fn DhcpSetOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u32;
7866         }
7867         ::std::mem::transmute(DhcpSetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7868     }
7869     #[cfg(not(windows))]
7870     unimplemented!("Unsupported target OS");
7871 }
7872 #[cfg(feature = "Win32_Foundation")]
7873 #[inline]
DhcpSetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u327874 pub unsafe fn DhcpSetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
7875     #[cfg(windows)]
7876     {
7877         #[link(name = "windows")]
7878         extern "system" {
7879             fn DhcpSetOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
7880         }
7881         ::std::mem::transmute(DhcpSetOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7882     }
7883     #[cfg(not(windows))]
7884     unimplemented!("Unsupported target OS");
7885 }
7886 #[cfg(feature = "Win32_Foundation")]
7887 #[inline]
DhcpSetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u327888 pub unsafe fn DhcpSetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
7889     #[cfg(windows)]
7890     {
7891         #[link(name = "windows")]
7892         extern "system" {
7893             fn DhcpSetOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
7894         }
7895         ::std::mem::transmute(DhcpSetOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7896     }
7897     #[cfg(not(windows))]
7898     unimplemented!("Unsupported target OS");
7899 }
7900 #[cfg(feature = "Win32_Foundation")]
7901 #[inline]
DhcpSetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u327902 pub unsafe fn DhcpSetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u32 {
7903     #[cfg(windows)]
7904     {
7905         #[link(name = "windows")]
7906         extern "system" {
7907             fn DhcpSetOptionValues(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u32;
7908         }
7909         ::std::mem::transmute(DhcpSetOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
7910     }
7911     #[cfg(not(windows))]
7912     unimplemented!("Unsupported target OS");
7913 }
7914 #[cfg(feature = "Win32_Foundation")]
7915 #[inline]
DhcpSetOptionValuesV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u327916 pub unsafe fn DhcpSetOptionValuesV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32 {
7917     #[cfg(windows)]
7918     {
7919         #[link(name = "windows")]
7920         extern "system" {
7921             fn DhcpSetOptionValuesV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32;
7922         }
7923         ::std::mem::transmute(DhcpSetOptionValuesV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
7924     }
7925     #[cfg(not(windows))]
7926     unimplemented!("Unsupported target OS");
7927 }
7928 #[cfg(feature = "Win32_Foundation")]
7929 #[inline]
DhcpSetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u327930 pub unsafe fn DhcpSetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u32 {
7931     #[cfg(windows)]
7932     {
7933         #[link(name = "windows")]
7934         extern "system" {
7935             fn DhcpSetServerBindingInfo(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u32;
7936         }
7937         ::std::mem::transmute(DhcpSetServerBindingInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementinfo)))
7938     }
7939     #[cfg(not(windows))]
7940     unimplemented!("Unsupported target OS");
7941 }
7942 #[cfg(feature = "Win32_Foundation")]
7943 #[inline]
DhcpSetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u327944 pub unsafe fn DhcpSetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32 {
7945     #[cfg(windows)]
7946     {
7947         #[link(name = "windows")]
7948         extern "system" {
7949             fn DhcpSetServerBindingInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32;
7950         }
7951         ::std::mem::transmute(DhcpSetServerBindingInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementinfo)))
7952     }
7953     #[cfg(not(windows))]
7954     unimplemented!("Unsupported target OS");
7955 }
7956 #[cfg(feature = "Win32_Foundation")]
7957 #[inline]
DhcpSetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: u16) -> u327958 pub unsafe fn DhcpSetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: u16) -> u32 {
7959     #[cfg(windows)]
7960     {
7961         #[link(name = "windows")]
7962         extern "system" {
7963             fn DhcpSetSubnetDelayOffer(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, timedelayinmilliseconds: u16) -> u32;
7964         }
7965         ::std::mem::transmute(DhcpSetSubnetDelayOffer(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(timedelayinmilliseconds)))
7966     }
7967     #[cfg(not(windows))]
7968     unimplemented!("Unsupported target OS");
7969 }
7970 #[cfg(feature = "Win32_Foundation")]
7971 #[inline]
DhcpSetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u327972 pub unsafe fn DhcpSetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32 {
7973     #[cfg(windows)]
7974     {
7975         #[link(name = "windows")]
7976         extern "system" {
7977             fn DhcpSetSubnetInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32;
7978         }
7979         ::std::mem::transmute(DhcpSetSubnetInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
7980     }
7981     #[cfg(not(windows))]
7982     unimplemented!("Unsupported target OS");
7983 }
7984 #[cfg(feature = "Win32_Foundation")]
7985 #[inline]
DhcpSetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u327986 pub unsafe fn DhcpSetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32 {
7987     #[cfg(windows)]
7988     {
7989         #[link(name = "windows")]
7990         extern "system" {
7991             fn DhcpSetSubnetInfoV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32;
7992         }
7993         ::std::mem::transmute(DhcpSetSubnetInfoV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
7994     }
7995     #[cfg(not(windows))]
7996     unimplemented!("Unsupported target OS");
7997 }
7998 #[cfg(feature = "Win32_Foundation")]
7999 #[inline]
DhcpSetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u328000 pub unsafe fn DhcpSetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32 {
8001     #[cfg(windows)]
8002     {
8003         #[link(name = "windows")]
8004         extern "system" {
8005             fn DhcpSetSubnetInfoVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32;
8006         }
8007         ::std::mem::transmute(DhcpSetSubnetInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
8008     }
8009     #[cfg(not(windows))]
8010     unimplemented!("Unsupported target OS");
8011 }
8012 #[cfg(feature = "Win32_Foundation")]
8013 #[inline]
DhcpSetSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, subnetaddress: u32, superscopename: Param2, changeexisting: Param3) -> u328014 pub unsafe fn DhcpSetSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, subnetaddress: u32, superscopename: Param2, changeexisting: Param3) -> u32 {
8015     #[cfg(windows)]
8016     {
8017         #[link(name = "windows")]
8018         extern "system" {
8019             fn DhcpSetSuperScopeV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, superscopename: super::super::Foundation::PWSTR, changeexisting: super::super::Foundation::BOOL) -> u32;
8020         }
8021         ::std::mem::transmute(DhcpSetSuperScopeV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), superscopename.into_param().abi(), changeexisting.into_param().abi()))
8022     }
8023     #[cfg(not(windows))]
8024     unimplemented!("Unsupported target OS");
8025 }
8026 #[inline]
DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u328027 pub unsafe fn DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u32 {
8028     #[cfg(windows)]
8029     {
8030         #[link(name = "windows")]
8031         extern "system" {
8032             fn DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u32;
8033         }
8034         ::std::mem::transmute(DhcpSetThreadOptions(::std::mem::transmute(flags), ::std::mem::transmute(reserved)))
8035     }
8036     #[cfg(not(windows))]
8037     unimplemented!("Unsupported target OS");
8038 }
8039 #[cfg(feature = "Win32_Foundation")]
8040 #[inline]
DhcpUndoRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, requestidstr: Param3) -> u328041 pub unsafe fn DhcpUndoRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, requestidstr: Param3) -> u32 {
8042     #[cfg(windows)]
8043     {
8044         #[link(name = "windows")]
8045         extern "system" {
8046             fn DhcpUndoRequestParams(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, requestidstr: super::super::Foundation::PWSTR) -> u32;
8047         }
8048         ::std::mem::transmute(DhcpUndoRequestParams(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), requestidstr.into_param().abi()))
8049     }
8050     #[cfg(not(windows))]
8051     unimplemented!("Unsupported target OS");
8052 }
8053 #[cfg(feature = "Win32_Foundation")]
8054 #[inline]
DhcpV4AddPolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u328055 pub unsafe fn DhcpV4AddPolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u32 {
8056     #[cfg(windows)]
8057     {
8058         #[link(name = "windows")]
8059         extern "system" {
8060             fn DhcpV4AddPolicyRange(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, range: *const DHCP_IP_RANGE) -> u32;
8061         }
8062         ::std::mem::transmute(DhcpV4AddPolicyRange(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(range)))
8063     }
8064     #[cfg(not(windows))]
8065     unimplemented!("Unsupported target OS");
8066 }
8067 #[cfg(feature = "Win32_Foundation")]
8068 #[inline]
DhcpV4CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u328069 pub unsafe fn DhcpV4CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u32 {
8070     #[cfg(windows)]
8071     {
8072         #[link(name = "windows")]
8073         extern "system" {
8074             fn DhcpV4CreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u32;
8075         }
8076         ::std::mem::transmute(DhcpV4CreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8077     }
8078     #[cfg(not(windows))]
8079     unimplemented!("Unsupported target OS");
8080 }
8081 #[cfg(feature = "Win32_Foundation")]
8082 #[inline]
DhcpV4CreateClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u328083 pub unsafe fn DhcpV4CreateClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u32 {
8084     #[cfg(windows)]
8085     {
8086         #[link(name = "windows")]
8087         extern "system" {
8088             fn DhcpV4CreateClientInfoEx(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u32;
8089         }
8090         ::std::mem::transmute(DhcpV4CreateClientInfoEx(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8091     }
8092     #[cfg(not(windows))]
8093     unimplemented!("Unsupported target OS");
8094 }
8095 #[cfg(feature = "Win32_Foundation")]
8096 #[inline]
DhcpV4CreatePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ppolicy: *const DHCP_POLICY) -> u328097 pub unsafe fn DhcpV4CreatePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ppolicy: *const DHCP_POLICY) -> u32 {
8098     #[cfg(windows)]
8099     {
8100         #[link(name = "windows")]
8101         extern "system" {
8102             fn DhcpV4CreatePolicy(serveripaddress: super::super::Foundation::PWSTR, ppolicy: *const DHCP_POLICY) -> u32;
8103         }
8104         ::std::mem::transmute(DhcpV4CreatePolicy(serveripaddress.into_param().abi(), ::std::mem::transmute(ppolicy)))
8105     }
8106     #[cfg(not(windows))]
8107     unimplemented!("Unsupported target OS");
8108 }
8109 #[cfg(feature = "Win32_Foundation")]
8110 #[inline]
DhcpV4CreatePolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, policyex: *const DHCP_POLICY_EX) -> u328111 pub unsafe fn DhcpV4CreatePolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, policyex: *const DHCP_POLICY_EX) -> u32 {
8112     #[cfg(windows)]
8113     {
8114         #[link(name = "windows")]
8115         extern "system" {
8116             fn DhcpV4CreatePolicyEx(serveripaddress: super::super::Foundation::PWSTR, policyex: *const DHCP_POLICY_EX) -> u32;
8117         }
8118         ::std::mem::transmute(DhcpV4CreatePolicyEx(serveripaddress.into_param().abi(), ::std::mem::transmute(policyex)))
8119     }
8120     #[cfg(not(windows))]
8121     unimplemented!("Unsupported target OS");
8122 }
8123 #[cfg(feature = "Win32_Foundation")]
8124 #[inline]
DhcpV4DeletePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3) -> u328125 pub unsafe fn DhcpV4DeletePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3) -> u32 {
8126     #[cfg(windows)]
8127     {
8128         #[link(name = "windows")]
8129         extern "system" {
8130             fn DhcpV4DeletePolicy(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR) -> u32;
8131         }
8132         ::std::mem::transmute(DhcpV4DeletePolicy(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi()))
8133     }
8134     #[cfg(not(windows))]
8135     unimplemented!("Unsupported target OS");
8136 }
8137 #[cfg(feature = "Win32_Foundation")]
8138 #[inline]
DhcpV4EnumPolicies<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328139 pub unsafe fn DhcpV4EnumPolicies<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8140     #[cfg(windows)]
8141     {
8142         #[link(name = "windows")]
8143         extern "system" {
8144             fn DhcpV4EnumPolicies(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8145         }
8146         ::std::mem::transmute(DhcpV4EnumPolicies(
8147             serveripaddress.into_param().abi(),
8148             ::std::mem::transmute(resumehandle),
8149             ::std::mem::transmute(preferredmaximum),
8150             fglobalpolicy.into_param().abi(),
8151             ::std::mem::transmute(subnetaddress),
8152             ::std::mem::transmute(enuminfo),
8153             ::std::mem::transmute(elementsread),
8154             ::std::mem::transmute(elementstotal),
8155         ))
8156     }
8157     #[cfg(not(windows))]
8158     unimplemented!("Unsupported target OS");
8159 }
8160 #[cfg(feature = "Win32_Foundation")]
8161 #[inline]
DhcpV4EnumPoliciesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328162 pub unsafe fn DhcpV4EnumPoliciesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8163     #[cfg(windows)]
8164     {
8165         #[link(name = "windows")]
8166         extern "system" {
8167             fn DhcpV4EnumPoliciesEx(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8168         }
8169         ::std::mem::transmute(DhcpV4EnumPoliciesEx(
8170             serveripaddress.into_param().abi(),
8171             ::std::mem::transmute(resumehandle),
8172             ::std::mem::transmute(preferredmaximum),
8173             globalpolicy.into_param().abi(),
8174             ::std::mem::transmute(subnetaddress),
8175             ::std::mem::transmute(enuminfo),
8176             ::std::mem::transmute(elementsread),
8177             ::std::mem::transmute(elementstotal),
8178         ))
8179     }
8180     #[cfg(not(windows))]
8181     unimplemented!("Unsupported target OS");
8182 }
8183 #[cfg(feature = "Win32_Foundation")]
8184 #[inline]
DhcpV4EnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u328185 pub unsafe fn DhcpV4EnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
8186     #[cfg(windows)]
8187     {
8188         #[link(name = "windows")]
8189         extern "system" {
8190             fn DhcpV4EnumSubnetClients(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
8191         }
8192         ::std::mem::transmute(DhcpV4EnumSubnetClients(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
8193     }
8194     #[cfg(not(windows))]
8195     unimplemented!("Unsupported target OS");
8196 }
8197 #[cfg(feature = "Win32_Foundation")]
8198 #[inline]
DhcpV4EnumSubnetClientsEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u328199 pub unsafe fn DhcpV4EnumSubnetClientsEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
8200     #[cfg(windows)]
8201     {
8202         #[link(name = "windows")]
8203         extern "system" {
8204             fn DhcpV4EnumSubnetClientsEx(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
8205         }
8206         ::std::mem::transmute(DhcpV4EnumSubnetClientsEx(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
8207     }
8208     #[cfg(not(windows))]
8209     unimplemented!("Unsupported target OS");
8210 }
8211 #[cfg(feature = "Win32_Foundation")]
8212 #[inline]
DhcpV4EnumSubnetReservations<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328213 pub unsafe fn DhcpV4EnumSubnetReservations<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8214     #[cfg(windows)]
8215     {
8216         #[link(name = "windows")]
8217         extern "system" {
8218             fn DhcpV4EnumSubnetReservations(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8219         }
8220         ::std::mem::transmute(DhcpV4EnumSubnetReservations(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enumelementinfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
8221     }
8222     #[cfg(not(windows))]
8223     unimplemented!("Unsupported target OS");
8224 }
8225 #[cfg(feature = "Win32_Foundation")]
8226 #[inline]
DhcpV4FailoverAddScopeToRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328227 pub unsafe fn DhcpV4FailoverAddScopeToRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8228     #[cfg(windows)]
8229     {
8230         #[link(name = "windows")]
8231         extern "system" {
8232             fn DhcpV4FailoverAddScopeToRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8233         }
8234         ::std::mem::transmute(DhcpV4FailoverAddScopeToRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8235     }
8236     #[cfg(not(windows))]
8237     unimplemented!("Unsupported target OS");
8238 }
8239 #[cfg(feature = "Win32_Foundation")]
8240 #[inline]
DhcpV4FailoverCreateRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328241 pub unsafe fn DhcpV4FailoverCreateRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8242     #[cfg(windows)]
8243     {
8244         #[link(name = "windows")]
8245         extern "system" {
8246             fn DhcpV4FailoverCreateRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8247         }
8248         ::std::mem::transmute(DhcpV4FailoverCreateRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8249     }
8250     #[cfg(not(windows))]
8251     unimplemented!("Unsupported target OS");
8252 }
8253 #[cfg(feature = "Win32_Foundation")]
8254 #[inline]
DhcpV4FailoverDeleteRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1) -> u328255 pub unsafe fn DhcpV4FailoverDeleteRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1) -> u32 {
8256     #[cfg(windows)]
8257     {
8258         #[link(name = "windows")]
8259         extern "system" {
8260             fn DhcpV4FailoverDeleteRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationshipname: super::super::Foundation::PWSTR) -> u32;
8261         }
8262         ::std::mem::transmute(DhcpV4FailoverDeleteRelationship(serveripaddress.into_param().abi(), prelationshipname.into_param().abi()))
8263     }
8264     #[cfg(not(windows))]
8265     unimplemented!("Unsupported target OS");
8266 }
8267 #[cfg(feature = "Win32_Foundation")]
8268 #[inline]
DhcpV4FailoverDeleteScopeFromRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328269 pub unsafe fn DhcpV4FailoverDeleteScopeFromRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8270     #[cfg(windows)]
8271     {
8272         #[link(name = "windows")]
8273         extern "system" {
8274             fn DhcpV4FailoverDeleteScopeFromRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8275         }
8276         ::std::mem::transmute(DhcpV4FailoverDeleteScopeFromRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8277     }
8278     #[cfg(not(windows))]
8279     unimplemented!("Unsupported target OS");
8280 }
8281 #[cfg(feature = "Win32_Foundation")]
8282 #[inline]
DhcpV4FailoverEnumRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u328283 pub unsafe fn DhcpV4FailoverEnumRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u32 {
8284     #[cfg(windows)]
8285     {
8286         #[link(name = "windows")]
8287         extern "system" {
8288             fn DhcpV4FailoverEnumRelationship(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u32;
8289         }
8290         ::std::mem::transmute(DhcpV4FailoverEnumRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(prelationship), ::std::mem::transmute(relationshipread), ::std::mem::transmute(relationshiptotal)))
8291     }
8292     #[cfg(not(windows))]
8293     unimplemented!("Unsupported target OS");
8294 }
8295 #[cfg(feature = "Win32_Foundation")]
8296 #[inline]
DhcpV4FailoverGetAddressStatus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, pstatus: *mut u32) -> u328297 pub unsafe fn DhcpV4FailoverGetAddressStatus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, pstatus: *mut u32) -> u32 {
8298     #[cfg(windows)]
8299     {
8300         #[link(name = "windows")]
8301         extern "system" {
8302             fn DhcpV4FailoverGetAddressStatus(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, pstatus: *mut u32) -> u32;
8303         }
8304         ::std::mem::transmute(DhcpV4FailoverGetAddressStatus(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(pstatus)))
8305     }
8306     #[cfg(not(windows))]
8307     unimplemented!("Unsupported target OS");
8308 }
8309 #[cfg(feature = "Win32_Foundation")]
8310 #[inline]
DhcpV4FailoverGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u328311 pub unsafe fn DhcpV4FailoverGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u32 {
8312     #[cfg(windows)]
8313     {
8314         #[link(name = "windows")]
8315         extern "system" {
8316             fn DhcpV4FailoverGetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u32;
8317         }
8318         ::std::mem::transmute(DhcpV4FailoverGetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8319     }
8320     #[cfg(not(windows))]
8321     unimplemented!("Unsupported target OS");
8322 }
8323 #[cfg(feature = "Win32_Foundation")]
8324 #[inline]
DhcpV4FailoverGetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u328325 pub unsafe fn DhcpV4FailoverGetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8326     #[cfg(windows)]
8327     {
8328         #[link(name = "windows")]
8329         extern "system" {
8330             fn DhcpV4FailoverGetRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationshipname: super::super::Foundation::PWSTR, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32;
8331         }
8332         ::std::mem::transmute(DhcpV4FailoverGetRelationship(serveripaddress.into_param().abi(), prelationshipname.into_param().abi(), ::std::mem::transmute(prelationship)))
8333     }
8334     #[cfg(not(windows))]
8335     unimplemented!("Unsupported target OS");
8336 }
8337 #[cfg(feature = "Win32_Foundation")]
8338 #[inline]
DhcpV4FailoverGetScopeRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u328339 pub unsafe fn DhcpV4FailoverGetScopeRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8340     #[cfg(windows)]
8341     {
8342         #[link(name = "windows")]
8343         extern "system" {
8344             fn DhcpV4FailoverGetScopeRelationship(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32;
8345         }
8346         ::std::mem::transmute(DhcpV4FailoverGetScopeRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(prelationship)))
8347     }
8348     #[cfg(not(windows))]
8349     unimplemented!("Unsupported target OS");
8350 }
8351 #[cfg(feature = "Win32_Foundation")]
8352 #[inline]
DhcpV4FailoverGetScopeStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u328353 pub unsafe fn DhcpV4FailoverGetScopeStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u32 {
8354     #[cfg(windows)]
8355     {
8356         #[link(name = "windows")]
8357         extern "system" {
8358             fn DhcpV4FailoverGetScopeStatistics(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u32;
8359         }
8360         ::std::mem::transmute(DhcpV4FailoverGetScopeStatistics(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(pstats)))
8361     }
8362     #[cfg(not(windows))]
8363     unimplemented!("Unsupported target OS");
8364 }
8365 #[cfg(feature = "Win32_Foundation")]
8366 #[inline]
DhcpV4FailoverGetSystemTime<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u328367 pub unsafe fn DhcpV4FailoverGetSystemTime<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u32 {
8368     #[cfg(windows)]
8369     {
8370         #[link(name = "windows")]
8371         extern "system" {
8372             fn DhcpV4FailoverGetSystemTime(serveripaddress: super::super::Foundation::PWSTR, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u32;
8373         }
8374         ::std::mem::transmute(DhcpV4FailoverGetSystemTime(serveripaddress.into_param().abi(), ::std::mem::transmute(ptime), ::std::mem::transmute(pmaxalloweddeltatime)))
8375     }
8376     #[cfg(not(windows))]
8377     unimplemented!("Unsupported target OS");
8378 }
8379 #[cfg(feature = "Win32_Foundation")]
8380 #[inline]
DhcpV4FailoverSetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328381 pub unsafe fn DhcpV4FailoverSetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8382     #[cfg(windows)]
8383     {
8384         #[link(name = "windows")]
8385         extern "system" {
8386             fn DhcpV4FailoverSetRelationship(serveripaddress: super::super::Foundation::PWSTR, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8387         }
8388         ::std::mem::transmute(DhcpV4FailoverSetRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(prelationship)))
8389     }
8390     #[cfg(not(windows))]
8391     unimplemented!("Unsupported target OS");
8392 }
8393 #[cfg(feature = "Win32_Foundation")]
8394 #[inline]
DhcpV4FailoverTriggerAddrAllocation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, pfailrelname: Param1) -> u328395 pub unsafe fn DhcpV4FailoverTriggerAddrAllocation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, pfailrelname: Param1) -> u32 {
8396     #[cfg(windows)]
8397     {
8398         #[link(name = "windows")]
8399         extern "system" {
8400             fn DhcpV4FailoverTriggerAddrAllocation(serveripaddress: super::super::Foundation::PWSTR, pfailrelname: super::super::Foundation::PWSTR) -> u32;
8401         }
8402         ::std::mem::transmute(DhcpV4FailoverTriggerAddrAllocation(serveripaddress.into_param().abi(), pfailrelname.into_param().abi()))
8403     }
8404     #[cfg(not(windows))]
8405     unimplemented!("Unsupported target OS");
8406 }
8407 #[cfg(feature = "Win32_Foundation")]
8408 #[inline]
DhcpV4GetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u328409 pub unsafe fn DhcpV4GetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u32 {
8410     #[cfg(windows)]
8411     {
8412         #[link(name = "windows")]
8413         extern "system" {
8414             fn DhcpV4GetAllOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u32;
8415         }
8416         ::std::mem::transmute(DhcpV4GetAllOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
8417     }
8418     #[cfg(not(windows))]
8419     unimplemented!("Unsupported target OS");
8420 }
8421 #[cfg(feature = "Win32_Foundation")]
8422 #[inline]
DhcpV4GetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u328423 pub unsafe fn DhcpV4GetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u32 {
8424     #[cfg(windows)]
8425     {
8426         #[link(name = "windows")]
8427         extern "system" {
8428             fn DhcpV4GetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u32;
8429         }
8430         ::std::mem::transmute(DhcpV4GetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8431     }
8432     #[cfg(not(windows))]
8433     unimplemented!("Unsupported target OS");
8434 }
8435 #[cfg(feature = "Win32_Foundation")]
8436 #[inline]
DhcpV4GetClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u328437 pub unsafe fn DhcpV4GetClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u32 {
8438     #[cfg(windows)]
8439     {
8440         #[link(name = "windows")]
8441         extern "system" {
8442             fn DhcpV4GetClientInfoEx(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u32;
8443         }
8444         ::std::mem::transmute(DhcpV4GetClientInfoEx(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8445     }
8446     #[cfg(not(windows))]
8447     unimplemented!("Unsupported target OS");
8448 }
8449 #[cfg(feature = "Win32_Foundation")]
8450 #[inline]
DhcpV4GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u328451 pub unsafe fn DhcpV4GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u32 {
8452     #[cfg(windows)]
8453     {
8454         #[link(name = "windows")]
8455         extern "system" {
8456             fn DhcpV4GetFreeIPAddress(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u32;
8457         }
8458         ::std::mem::transmute(DhcpV4GetFreeIPAddress(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(startip), ::std::mem::transmute(endip), ::std::mem::transmute(numfreeaddrreq), ::std::mem::transmute(ipaddrlist)))
8459     }
8460     #[cfg(not(windows))]
8461     unimplemented!("Unsupported target OS");
8462 }
8463 #[cfg(feature = "Win32_Foundation")]
8464 #[inline]
DhcpV4GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u328465 pub unsafe fn DhcpV4GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
8466     #[cfg(windows)]
8467     {
8468         #[link(name = "windows")]
8469         extern "system" {
8470             fn DhcpV4GetOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
8471         }
8472         ::std::mem::transmute(DhcpV4GetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
8473     }
8474     #[cfg(not(windows))]
8475     unimplemented!("Unsupported target OS");
8476 }
8477 #[cfg(feature = "Win32_Foundation")]
8478 #[inline]
DhcpV4GetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY) -> u328479 pub unsafe fn DhcpV4GetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY) -> u32 {
8480     #[cfg(windows)]
8481     {
8482         #[link(name = "windows")]
8483         extern "system" {
8484             fn DhcpV4GetPolicy(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *mut *mut DHCP_POLICY) -> u32;
8485         }
8486         ::std::mem::transmute(DhcpV4GetPolicy(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8487     }
8488     #[cfg(not(windows))]
8489     unimplemented!("Unsupported target OS");
8490 }
8491 #[cfg(feature = "Win32_Foundation")]
8492 #[inline]
DhcpV4GetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY_EX) -> u328493 pub unsafe fn DhcpV4GetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY_EX) -> u32 {
8494     #[cfg(windows)]
8495     {
8496         #[link(name = "windows")]
8497         extern "system" {
8498             fn DhcpV4GetPolicyEx(serveripaddress: super::super::Foundation::PWSTR, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *mut *mut DHCP_POLICY_EX) -> u32;
8499         }
8500         ::std::mem::transmute(DhcpV4GetPolicyEx(serveripaddress.into_param().abi(), globalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8501     }
8502     #[cfg(not(windows))]
8503     unimplemented!("Unsupported target OS");
8504 }
8505 #[cfg(feature = "Win32_Foundation")]
8506 #[inline]
DhcpV4QueryPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u328507 pub unsafe fn DhcpV4QueryPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u32 {
8508     #[cfg(windows)]
8509     {
8510         #[link(name = "windows")]
8511         extern "system" {
8512             fn DhcpV4QueryPolicyEnforcement(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u32;
8513         }
8514         ::std::mem::transmute(DhcpV4QueryPolicyEnforcement(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(enabled)))
8515     }
8516     #[cfg(not(windows))]
8517     unimplemented!("Unsupported target OS");
8518 }
8519 #[cfg(feature = "Win32_Foundation")]
8520 #[inline]
DhcpV4RemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u328521 pub unsafe fn DhcpV4RemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32 {
8522     #[cfg(windows)]
8523     {
8524         #[link(name = "windows")]
8525         extern "system" {
8526             fn DhcpV4RemoveOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32;
8527         }
8528         ::std::mem::transmute(DhcpV4RemoveOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
8529     }
8530     #[cfg(not(windows))]
8531     unimplemented!("Unsupported target OS");
8532 }
8533 #[cfg(feature = "Win32_Foundation")]
8534 #[inline]
DhcpV4RemovePolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u328535 pub unsafe fn DhcpV4RemovePolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u32 {
8536     #[cfg(windows)]
8537     {
8538         #[link(name = "windows")]
8539         extern "system" {
8540             fn DhcpV4RemovePolicyRange(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, range: *const DHCP_IP_RANGE) -> u32;
8541         }
8542         ::std::mem::transmute(DhcpV4RemovePolicyRange(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(range)))
8543     }
8544     #[cfg(not(windows))]
8545     unimplemented!("Unsupported target OS");
8546 }
8547 #[cfg(feature = "Win32_Foundation")]
8548 #[inline]
DhcpV4SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u328549 pub unsafe fn DhcpV4SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
8550     #[cfg(windows)]
8551     {
8552         #[link(name = "windows")]
8553         extern "system" {
8554             fn DhcpV4SetOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
8555         }
8556         ::std::mem::transmute(DhcpV4SetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
8557     }
8558     #[cfg(not(windows))]
8559     unimplemented!("Unsupported target OS");
8560 }
8561 #[cfg(feature = "Win32_Foundation")]
8562 #[inline]
DhcpV4SetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, policyname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u328563 pub unsafe fn DhcpV4SetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, policyname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32 {
8564     #[cfg(windows)]
8565     {
8566         #[link(name = "windows")]
8567         extern "system" {
8568             fn DhcpV4SetOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32;
8569         }
8570         ::std::mem::transmute(DhcpV4SetOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
8571     }
8572     #[cfg(not(windows))]
8573     unimplemented!("Unsupported target OS");
8574 }
8575 #[cfg(feature = "Win32_Foundation")]
8576 #[inline]
DhcpV4SetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, fglobalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY) -> u328577 pub unsafe fn DhcpV4SetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, fglobalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY) -> u32 {
8578     #[cfg(windows)]
8579     {
8580         #[link(name = "windows")]
8581         extern "system" {
8582             fn DhcpV4SetPolicy(serveripaddress: super::super::Foundation::PWSTR, fieldsmodified: u32, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *const DHCP_POLICY) -> u32;
8583         }
8584         ::std::mem::transmute(DhcpV4SetPolicy(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldsmodified), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8585     }
8586     #[cfg(not(windows))]
8587     unimplemented!("Unsupported target OS");
8588 }
8589 #[cfg(feature = "Win32_Foundation")]
8590 #[inline]
DhcpV4SetPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enable: Param3) -> u328591 pub unsafe fn DhcpV4SetPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enable: Param3) -> u32 {
8592     #[cfg(windows)]
8593     {
8594         #[link(name = "windows")]
8595         extern "system" {
8596             fn DhcpV4SetPolicyEnforcement(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enable: super::super::Foundation::BOOL) -> u32;
8597         }
8598         ::std::mem::transmute(DhcpV4SetPolicyEnforcement(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), enable.into_param().abi()))
8599     }
8600     #[cfg(not(windows))]
8601     unimplemented!("Unsupported target OS");
8602 }
8603 #[cfg(feature = "Win32_Foundation")]
8604 #[inline]
DhcpV4SetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, globalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY_EX) -> u328605 pub unsafe fn DhcpV4SetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, globalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY_EX) -> u32 {
8606     #[cfg(windows)]
8607     {
8608         #[link(name = "windows")]
8609         extern "system" {
8610             fn DhcpV4SetPolicyEx(serveripaddress: super::super::Foundation::PWSTR, fieldsmodified: u32, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *const DHCP_POLICY_EX) -> u32;
8611         }
8612         ::std::mem::transmute(DhcpV4SetPolicyEx(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldsmodified), globalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8613     }
8614     #[cfg(not(windows))]
8615     unimplemented!("Unsupported target OS");
8616 }
8617 #[cfg(feature = "Win32_Foundation")]
8618 #[inline]
DhcpV6CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u328619 pub unsafe fn DhcpV6CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32 {
8620     #[cfg(windows)]
8621     {
8622         #[link(name = "windows")]
8623         extern "system" {
8624             fn DhcpV6CreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32;
8625         }
8626         ::std::mem::transmute(DhcpV6CreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8627     }
8628     #[cfg(not(windows))]
8629     unimplemented!("Unsupported target OS");
8630 }
8631 #[cfg(feature = "Win32_Foundation")]
8632 #[inline]
DhcpV6GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param3: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, scopeid: Param1, startip: Param2, endip: Param3, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u328633 pub unsafe fn DhcpV6GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param3: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, scopeid: Param1, startip: Param2, endip: Param3, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u32 {
8634     #[cfg(windows)]
8635     {
8636         #[link(name = "windows")]
8637         extern "system" {
8638             fn DhcpV6GetFreeIPAddress(serveripaddress: super::super::Foundation::PWSTR, scopeid: DHCP_IPV6_ADDRESS, startip: DHCP_IPV6_ADDRESS, endip: DHCP_IPV6_ADDRESS, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u32;
8639         }
8640         ::std::mem::transmute(DhcpV6GetFreeIPAddress(serveripaddress.into_param().abi(), scopeid.into_param().abi(), startip.into_param().abi(), endip.into_param().abi(), ::std::mem::transmute(numfreeaddrreq), ::std::mem::transmute(ipaddrlist)))
8641     }
8642     #[cfg(not(windows))]
8643     unimplemented!("Unsupported target OS");
8644 }
8645 #[cfg(feature = "Win32_Foundation")]
8646 #[inline]
DhcpV6GetStatelessStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u328647 pub unsafe fn DhcpV6GetStatelessStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u32 {
8648     #[cfg(windows)]
8649     {
8650         #[link(name = "windows")]
8651         extern "system" {
8652             fn DhcpV6GetStatelessStatistics(serveripaddress: super::super::Foundation::PWSTR, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u32;
8653         }
8654         ::std::mem::transmute(DhcpV6GetStatelessStatistics(serveripaddress.into_param().abi(), ::std::mem::transmute(statelessstats)))
8655     }
8656     #[cfg(not(windows))]
8657     unimplemented!("Unsupported target OS");
8658 }
8659 #[cfg(feature = "Win32_Foundation")]
8660 #[inline]
DhcpV6GetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u328661 pub unsafe fn DhcpV6GetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u32 {
8662     #[cfg(windows)]
8663     {
8664         #[link(name = "windows")]
8665         extern "system" {
8666             fn DhcpV6GetStatelessStoreParams(serveripaddress: super::super::Foundation::PWSTR, fserverlevel: super::super::Foundation::BOOL, subnetaddress: DHCP_IPV6_ADDRESS, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u32;
8667         }
8668         ::std::mem::transmute(DhcpV6GetStatelessStoreParams(serveripaddress.into_param().abi(), fserverlevel.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(params)))
8669     }
8670     #[cfg(not(windows))]
8671     unimplemented!("Unsupported target OS");
8672 }
8673 #[cfg(feature = "Win32_Foundation")]
8674 #[inline]
DhcpV6SetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u328675 pub unsafe fn DhcpV6SetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u32 {
8676     #[cfg(windows)]
8677     {
8678         #[link(name = "windows")]
8679         extern "system" {
8680             fn DhcpV6SetStatelessStoreParams(serveripaddress: super::super::Foundation::PWSTR, fserverlevel: super::super::Foundation::BOOL, subnetaddress: DHCP_IPV6_ADDRESS, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u32;
8681         }
8682         ::std::mem::transmute(DhcpV6SetStatelessStoreParams(serveripaddress.into_param().abi(), fserverlevel.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(fieldmodified), ::std::mem::transmute(params)))
8683     }
8684     #[cfg(not(windows))]
8685     unimplemented!("Unsupported target OS");
8686 }
8687 #[inline]
Dhcpv6CApiCleanup()8688 pub unsafe fn Dhcpv6CApiCleanup() {
8689     #[cfg(windows)]
8690     {
8691         #[link(name = "windows")]
8692         extern "system" {
8693             fn Dhcpv6CApiCleanup();
8694         }
8695         ::std::mem::transmute(Dhcpv6CApiCleanup())
8696     }
8697     #[cfg(not(windows))]
8698     unimplemented!("Unsupported target OS");
8699 }
8700 #[inline]
Dhcpv6CApiInitialize(version: *mut u32)8701 pub unsafe fn Dhcpv6CApiInitialize(version: *mut u32) {
8702     #[cfg(windows)]
8703     {
8704         #[link(name = "windows")]
8705         extern "system" {
8706             fn Dhcpv6CApiInitialize(version: *mut u32);
8707         }
8708         ::std::mem::transmute(Dhcpv6CApiInitialize(::std::mem::transmute(version)))
8709     }
8710     #[cfg(not(windows))]
8711     unimplemented!("Unsupported target OS");
8712 }
8713 #[cfg(feature = "Win32_Foundation")]
8714 #[inline]
Dhcpv6ReleasePrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u328715 pub unsafe fn Dhcpv6ReleasePrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u32 {
8716     #[cfg(windows)]
8717     {
8718         #[link(name = "windows")]
8719         extern "system" {
8720             fn Dhcpv6ReleasePrefix(adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u32;
8721         }
8722         ::std::mem::transmute(Dhcpv6ReleasePrefix(adaptername.into_param().abi(), ::std::mem::transmute(classid), ::std::mem::transmute(leaseinfo)))
8723     }
8724     #[cfg(not(windows))]
8725     unimplemented!("Unsupported target OS");
8726 }
8727 #[cfg(feature = "Win32_Foundation")]
8728 #[inline]
Dhcpv6RenewPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u328729 pub unsafe fn Dhcpv6RenewPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u32 {
8730     #[cfg(windows)]
8731     {
8732         #[link(name = "windows")]
8733         extern "system" {
8734             fn Dhcpv6RenewPrefix(adaptername: super::super::Foundation::PWSTR, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u32;
8735         }
8736         ::std::mem::transmute(Dhcpv6RenewPrefix(adaptername.into_param().abi(), ::std::mem::transmute(pclassid), ::std::mem::transmute(prefixleaseinfo), ::std::mem::transmute(pdwtimetowait), ::std::mem::transmute(bvalidateprefix)))
8737     }
8738     #[cfg(not(windows))]
8739     unimplemented!("Unsupported target OS");
8740 }
8741 #[cfg(feature = "Win32_Foundation")]
8742 #[inline]
Dhcpv6RequestParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPV6CAPI_PARAMS_ARRAY>>(forcenewinform: Param0, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPV6CAPI_CLASSID, recdparams: Param4, buffer: *mut u8, psize: *mut u32) -> u328743 pub unsafe fn Dhcpv6RequestParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPV6CAPI_PARAMS_ARRAY>>(forcenewinform: Param0, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPV6CAPI_CLASSID, recdparams: Param4, buffer: *mut u8, psize: *mut u32) -> u32 {
8744     #[cfg(windows)]
8745     {
8746         #[link(name = "windows")]
8747         extern "system" {
8748             fn Dhcpv6RequestParams(forcenewinform: super::super::Foundation::BOOL, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPV6CAPI_CLASSID, recdparams: DHCPV6CAPI_PARAMS_ARRAY, buffer: *mut u8, psize: *mut u32) -> u32;
8749         }
8750         ::std::mem::transmute(Dhcpv6RequestParams(forcenewinform.into_param().abi(), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), recdparams.into_param().abi(), ::std::mem::transmute(buffer), ::std::mem::transmute(psize)))
8751     }
8752     #[cfg(not(windows))]
8753     unimplemented!("Unsupported target OS");
8754 }
8755 #[cfg(feature = "Win32_Foundation")]
8756 #[inline]
Dhcpv6RequestPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u328757 pub unsafe fn Dhcpv6RequestPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u32 {
8758     #[cfg(windows)]
8759     {
8760         #[link(name = "windows")]
8761         extern "system" {
8762             fn Dhcpv6RequestPrefix(adaptername: super::super::Foundation::PWSTR, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u32;
8763         }
8764         ::std::mem::transmute(Dhcpv6RequestPrefix(adaptername.into_param().abi(), ::std::mem::transmute(pclassid), ::std::mem::transmute(prefixleaseinfo), ::std::mem::transmute(pdwtimetowait)))
8765     }
8766     #[cfg(not(windows))]
8767     unimplemented!("Unsupported target OS");
8768 }
8769 pub const ERROR_DDS_CLASS_DOES_NOT_EXIST: u32 = 20078u32;
8770 pub const ERROR_DDS_CLASS_EXISTS: u32 = 20077u32;
8771 pub const ERROR_DDS_DHCP_SERVER_NOT_FOUND: u32 = 20074u32;
8772 pub const ERROR_DDS_NO_DHCP_ROOT: u32 = 20071u32;
8773 pub const ERROR_DDS_NO_DS_AVAILABLE: u32 = 20070u32;
8774 pub const ERROR_DDS_OPTION_ALREADY_EXISTS: u32 = 20075u32;
8775 pub const ERROR_DDS_OPTION_DOES_NOT_EXIST: u32 = 20076u32;
8776 pub const ERROR_DDS_POSSIBLE_RANGE_CONFLICT: u32 = 20087u32;
8777 pub const ERROR_DDS_RANGE_DOES_NOT_EXIST: u32 = 20088u32;
8778 pub const ERROR_DDS_RESERVATION_CONFLICT: u32 = 20086u32;
8779 pub const ERROR_DDS_RESERVATION_NOT_PRESENT: u32 = 20085u32;
8780 pub const ERROR_DDS_SERVER_ADDRESS_MISMATCH: u32 = 20081u32;
8781 pub const ERROR_DDS_SERVER_ALREADY_EXISTS: u32 = 20079u32;
8782 pub const ERROR_DDS_SERVER_DOES_NOT_EXIST: u32 = 20080u32;
8783 pub const ERROR_DDS_SUBNET_EXISTS: u32 = 20082u32;
8784 pub const ERROR_DDS_SUBNET_HAS_DIFF_SSCOPE: u32 = 20083u32;
8785 pub const ERROR_DDS_SUBNET_NOT_PRESENT: u32 = 20084u32;
8786 pub const ERROR_DDS_TOO_MANY_ERRORS: u32 = 20073u32;
8787 pub const ERROR_DDS_UNEXPECTED_ERROR: u32 = 20072u32;
8788 pub const ERROR_DHCP_ADDRESS_NOT_AVAILABLE: u32 = 20011u32;
8789 pub const ERROR_DHCP_CANNOT_MODIFY_BINDINGS: u32 = 20051u32;
8790 pub const ERROR_DHCP_CANT_CHANGE_ATTRIBUTE: u32 = 20048u32;
8791 pub const ERROR_DHCP_CLASS_ALREADY_EXISTS: u32 = 20045u32;
8792 pub const ERROR_DHCP_CLASS_NOT_FOUND: u32 = 20044u32;
8793 pub const ERROR_DHCP_CLIENT_EXISTS: u32 = 20014u32;
8794 pub const ERROR_DHCP_DATABASE_INIT_FAILED: u32 = 20001u32;
8795 pub const ERROR_DHCP_DEFAULT_SCOPE_EXITS: u32 = 20047u32;
8796 pub const ERROR_DHCP_DELETE_BUILTIN_CLASS: u32 = 20089u32;
8797 pub const ERROR_DHCP_ELEMENT_CANT_REMOVE: u32 = 20007u32;
8798 pub const ERROR_DHCP_EXEMPTION_EXISTS: u32 = 20055u32;
8799 pub const ERROR_DHCP_EXEMPTION_NOT_PRESENT: u32 = 20056u32;
8800 pub const ERROR_DHCP_FO_ADDSCOPE_LEASES_NOT_SYNCED: u32 = 20127u32;
8801 pub const ERROR_DHCP_FO_BOOT_NOT_SUPPORTED: u32 = 20131u32;
8802 pub const ERROR_DHCP_FO_FEATURE_NOT_SUPPORTED: u32 = 20134u32;
8803 pub const ERROR_DHCP_FO_IPRANGE_TYPE_CONV_ILLEGAL: u32 = 20129u32;
8804 pub const ERROR_DHCP_FO_MAX_ADD_SCOPES: u32 = 20130u32;
8805 pub const ERROR_DHCP_FO_MAX_RELATIONSHIPS: u32 = 20128u32;
8806 pub const ERROR_DHCP_FO_NOT_SUPPORTED: u32 = 20118u32;
8807 pub const ERROR_DHCP_FO_RANGE_PART_OF_REL: u32 = 20132u32;
8808 pub const ERROR_DHCP_FO_RELATIONSHIP_DOES_NOT_EXIST: u32 = 20115u32;
8809 pub const ERROR_DHCP_FO_RELATIONSHIP_EXISTS: u32 = 20114u32;
8810 pub const ERROR_DHCP_FO_RELATIONSHIP_NAME_TOO_LONG: u32 = 20125u32;
8811 pub const ERROR_DHCP_FO_RELATION_IS_SECONDARY: u32 = 20117u32;
8812 pub const ERROR_DHCP_FO_SCOPE_ALREADY_IN_RELATIONSHIP: u32 = 20113u32;
8813 pub const ERROR_DHCP_FO_SCOPE_NOT_IN_RELATIONSHIP: u32 = 20116u32;
8814 pub const ERROR_DHCP_FO_SCOPE_SYNC_IN_PROGRESS: u32 = 20133u32;
8815 pub const ERROR_DHCP_FO_STATE_NOT_NORMAL: u32 = 20120u32;
8816 pub const ERROR_DHCP_FO_TIME_OUT_OF_SYNC: u32 = 20119u32;
8817 pub const ERROR_DHCP_HARDWARE_ADDRESS_TYPE_ALREADY_EXEMPT: u32 = 20101u32;
8818 pub const ERROR_DHCP_INVALID_DELAY: u32 = 20092u32;
8819 pub const ERROR_DHCP_INVALID_DHCP_CLIENT: u32 = 20016u32;
8820 pub const ERROR_DHCP_INVALID_DHCP_MESSAGE: u32 = 20015u32;
8821 pub const ERROR_DHCP_INVALID_PARAMETER_OPTION32: u32 = 20057u32;
8822 pub const ERROR_DHCP_INVALID_POLICY_EXPRESSION: u32 = 20109u32;
8823 pub const ERROR_DHCP_INVALID_PROCESSING_ORDER: u32 = 20110u32;
8824 pub const ERROR_DHCP_INVALID_RANGE: u32 = 20023u32;
8825 pub const ERROR_DHCP_INVALID_SUBNET_PREFIX: u32 = 20091u32;
8826 pub const ERROR_DHCP_IPRANGE_CONV_ILLEGAL: u32 = 20049u32;
8827 pub const ERROR_DHCP_IPRANGE_EXITS: u32 = 20021u32;
8828 pub const ERROR_DHCP_IP_ADDRESS_IN_USE: u32 = 20032u32;
8829 pub const ERROR_DHCP_JET97_CONV_REQUIRED: u32 = 20036u32;
8830 pub const ERROR_DHCP_JET_CONV_REQUIRED: u32 = 20027u32;
8831 pub const ERROR_DHCP_JET_ERROR: u32 = 20013u32;
8832 pub const ERROR_DHCP_LINKLAYER_ADDRESS_DOES_NOT_EXIST: u32 = 20095u32;
8833 pub const ERROR_DHCP_LINKLAYER_ADDRESS_EXISTS: u32 = 20093u32;
8834 pub const ERROR_DHCP_LINKLAYER_ADDRESS_RESERVATION_EXISTS: u32 = 20094u32;
8835 pub const ERROR_DHCP_LOG_FILE_PATH_TOO_LONG: u32 = 20033u32;
8836 pub const ERROR_DHCP_MSCOPE_EXISTS: u32 = 20053u32;
8837 pub const ERROR_DHCP_NAP_NOT_SUPPORTED: u32 = 20138u32;
8838 pub const ERROR_DHCP_NETWORK_CHANGED: u32 = 20050u32;
8839 pub const ERROR_DHCP_NETWORK_INIT_FAILED: u32 = 20003u32;
8840 pub const ERROR_DHCP_NOT_RESERVED_CLIENT: u32 = 20018u32;
8841 pub const ERROR_DHCP_NO_ADMIN_PERMISSION: u32 = 20121u32;
8842 pub const ERROR_DHCP_OPTION_EXITS: u32 = 20009u32;
8843 pub const ERROR_DHCP_OPTION_NOT_PRESENT: u32 = 20010u32;
8844 pub const ERROR_DHCP_OPTION_TYPE_MISMATCH: u32 = 20103u32;
8845 pub const ERROR_DHCP_POLICY_BAD_PARENT_EXPR: u32 = 20104u32;
8846 pub const ERROR_DHCP_POLICY_EDIT_FQDN_UNSUPPORTED: u32 = 20137u32;
8847 pub const ERROR_DHCP_POLICY_EXISTS: u32 = 20105u32;
8848 pub const ERROR_DHCP_POLICY_FQDN_OPTION_UNSUPPORTED: u32 = 20136u32;
8849 pub const ERROR_DHCP_POLICY_FQDN_RANGE_UNSUPPORTED: u32 = 20135u32;
8850 pub const ERROR_DHCP_POLICY_NOT_FOUND: u32 = 20111u32;
8851 pub const ERROR_DHCP_POLICY_RANGE_BAD: u32 = 20107u32;
8852 pub const ERROR_DHCP_POLICY_RANGE_EXISTS: u32 = 20106u32;
8853 pub const ERROR_DHCP_PRIMARY_NOT_FOUND: u32 = 20006u32;
8854 pub const ERROR_DHCP_RANGE_EXTENDED: u32 = 20024u32;
8855 pub const ERROR_DHCP_RANGE_FULL: u32 = 20012u32;
8856 pub const ERROR_DHCP_RANGE_INVALID_IN_SERVER_POLICY: u32 = 20108u32;
8857 pub const ERROR_DHCP_RANGE_TOO_SMALL: u32 = 20020u32;
8858 pub const ERROR_DHCP_REACHED_END_OF_SELECTION: u32 = 20126u32;
8859 pub const ERROR_DHCP_REGISTRY_INIT_FAILED: u32 = 20000u32;
8860 pub const ERROR_DHCP_RESERVEDIP_EXITS: u32 = 20022u32;
8861 pub const ERROR_DHCP_RESERVED_CLIENT: u32 = 20019u32;
8862 pub const ERROR_DHCP_ROGUE_DS_CONFLICT: u32 = 20041u32;
8863 pub const ERROR_DHCP_ROGUE_DS_UNREACHABLE: u32 = 20040u32;
8864 pub const ERROR_DHCP_ROGUE_INIT_FAILED: u32 = 20037u32;
8865 pub const ERROR_DHCP_ROGUE_NOT_AUTHORIZED: u32 = 20039u32;
8866 pub const ERROR_DHCP_ROGUE_NOT_OUR_ENTERPRISE: u32 = 20042u32;
8867 pub const ERROR_DHCP_ROGUE_SAMSHUTDOWN: u32 = 20038u32;
8868 pub const ERROR_DHCP_ROGUE_STANDALONE_IN_DS: u32 = 20043u32;
8869 pub const ERROR_DHCP_RPC_INIT_FAILED: u32 = 20002u32;
8870 pub const ERROR_DHCP_SCOPE_NAME_TOO_LONG: u32 = 20046u32;
8871 pub const ERROR_DHCP_SERVER_NAME_NOT_RESOLVED: u32 = 20124u32;
8872 pub const ERROR_DHCP_SERVER_NOT_REACHABLE: u32 = 20122u32;
8873 pub const ERROR_DHCP_SERVER_NOT_RUNNING: u32 = 20123u32;
8874 pub const ERROR_DHCP_SERVICE_PAUSED: u32 = 20017u32;
8875 pub const ERROR_DHCP_SUBNET_EXISTS: u32 = 20052u32;
8876 pub const ERROR_DHCP_SUBNET_EXITS: u32 = 20004u32;
8877 pub const ERROR_DHCP_SUBNET_NOT_PRESENT: u32 = 20005u32;
8878 pub const ERROR_DHCP_SUPER_SCOPE_NAME_TOO_LONG: u32 = 20030u32;
8879 pub const ERROR_DHCP_UNDEFINED_HARDWARE_ADDRESS_TYPE: u32 = 20102u32;
8880 pub const ERROR_DHCP_UNSUPPORTED_CLIENT: u32 = 20034u32;
8881 pub const ERROR_EXTEND_TOO_SMALL: u32 = 20025u32;
8882 pub const ERROR_LAST_DHCP_SERVER_ERROR: u32 = 20139u32;
8883 pub const ERROR_MSCOPE_RANGE_TOO_SMALL: u32 = 20054u32;
8884 pub const ERROR_SCOPE_RANGE_POLICY_RANGE_CONFLICT: u32 = 20112u32;
8885 pub const ERROR_SERVER_INVALID_BOOT_FILE_TABLE: u32 = 20028u32;
8886 pub const ERROR_SERVER_UNKNOWN_BOOT_FILE_NAME: u32 = 20029u32;
8887 pub const FILTER_STATUS_FULL_MATCH_IN_ALLOW_LIST: u32 = 2u32;
8888 pub const FILTER_STATUS_FULL_MATCH_IN_DENY_LIST: u32 = 4u32;
8889 pub const FILTER_STATUS_NONE: u32 = 1u32;
8890 pub const FILTER_STATUS_WILDCARD_MATCH_IN_ALLOW_LIST: u32 = 8u32;
8891 pub const FILTER_STATUS_WILDCARD_MATCH_IN_DENY_LIST: u32 = 16u32;
8892 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8893 #[repr(transparent)]
8894 pub struct FSM_STATE(pub i32);
8895 pub const NO_STATE: FSM_STATE = FSM_STATE(0i32);
8896 pub const INIT: FSM_STATE = FSM_STATE(1i32);
8897 pub const STARTUP: FSM_STATE = FSM_STATE(2i32);
8898 pub const NORMAL: FSM_STATE = FSM_STATE(3i32);
8899 pub const COMMUNICATION_INT: FSM_STATE = FSM_STATE(4i32);
8900 pub const PARTNER_DOWN: FSM_STATE = FSM_STATE(5i32);
8901 pub const POTENTIAL_CONFLICT: FSM_STATE = FSM_STATE(6i32);
8902 pub const CONFLICT_DONE: FSM_STATE = FSM_STATE(7i32);
8903 pub const RESOLUTION_INT: FSM_STATE = FSM_STATE(8i32);
8904 pub const RECOVER: FSM_STATE = FSM_STATE(9i32);
8905 pub const RECOVER_WAIT: FSM_STATE = FSM_STATE(10i32);
8906 pub const RECOVER_DONE: FSM_STATE = FSM_STATE(11i32);
8907 pub const PAUSED: FSM_STATE = FSM_STATE(12i32);
8908 pub const SHUTDOWN: FSM_STATE = FSM_STATE(13i32);
8909 impl ::std::convert::From<i32> for FSM_STATE {
from(value: i32) -> Self8910     fn from(value: i32) -> Self {
8911         Self(value)
8912     }
8913 }
8914 unsafe impl ::windows::runtime::Abi for FSM_STATE {
8915     type Abi = Self;
8916     type DefaultType = Self;
8917 }
8918 pub const HWTYPE_ETHERNET_10MB: u32 = 1u32;
8919 pub type LPDHCP_CONTROL = unsafe extern "system" fn(dwcontrolcode: u32, lpreserved: *mut ::std::ffi::c_void) -> u32;
8920 pub type LPDHCP_DELETE_CLIENT = unsafe extern "system" fn(ipaddress: u32, hwaddress: *mut u8, hwaddresslength: u32, reserved: u32, clienttype: u32) -> u32;
8921 pub type LPDHCP_DROP_SEND = unsafe extern "system" fn(packet: *mut *mut u8, packetsize: *mut u32, controlcode: u32, ipaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8922 #[cfg(feature = "Win32_Foundation")]
8923 pub type LPDHCP_ENTRY_POINT_FUNC = unsafe extern "system" fn(chaindlls: super::super::Foundation::PWSTR, calloutversion: u32, callouttbl: *mut ::std::mem::ManuallyDrop<DHCP_CALLOUT_TABLE>) -> u32;
8924 pub type LPDHCP_GIVE_ADDRESS = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, controlcode: u32, ipaddress: u32, altaddress: u32, addrtype: u32, leasetime: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8925 #[cfg(feature = "Win32_Foundation")]
8926 pub type LPDHCP_HANDLE_OPTIONS = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void, serveroptions: *mut DHCP_SERVER_OPTIONS) -> u32;
8927 pub type LPDHCP_NEWPKT = unsafe extern "system" fn(packet: *mut *mut u8, packetsize: *mut u32, ipaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut *mut ::std::ffi::c_void, processit: *mut i32) -> u32;
8928 pub type LPDHCP_PROB = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, controlcode: u32, ipaddress: u32, altaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8929 pub const MAC_ADDRESS_LENGTH: u32 = 6u32;
8930 pub const MAX_PATTERN_LENGTH: u32 = 255u32;
8931 pub const MCLT: u32 = 1u32;
8932 pub const MODE: u32 = 16u32;
8933 pub const OPTION_ALL_SUBNETS_MTU: u32 = 27u32;
8934 pub const OPTION_ARP_CACHE_TIMEOUT: u32 = 35u32;
8935 pub const OPTION_BE_A_MASK_SUPPLIER: u32 = 30u32;
8936 pub const OPTION_BE_A_ROUTER: u32 = 19u32;
8937 pub const OPTION_BOOTFILE_NAME: u32 = 67u32;
8938 pub const OPTION_BOOT_FILE_SIZE: u32 = 13u32;
8939 pub const OPTION_BROADCAST_ADDRESS: u32 = 28u32;
8940 pub const OPTION_CLIENT_CLASS_INFO: u32 = 60u32;
8941 pub const OPTION_CLIENT_ID: u32 = 61u32;
8942 pub const OPTION_COOKIE_SERVERS: u32 = 8u32;
8943 pub const OPTION_DEFAULT_TTL: u32 = 23u32;
8944 pub const OPTION_DOMAIN_NAME: u32 = 15u32;
8945 pub const OPTION_DOMAIN_NAME_SERVERS: u32 = 6u32;
8946 pub const OPTION_END: u32 = 255u32;
8947 pub const OPTION_ETHERNET_ENCAPSULATION: u32 = 36u32;
8948 pub const OPTION_EXTENSIONS_PATH: u32 = 18u32;
8949 pub const OPTION_HOST_NAME: u32 = 12u32;
8950 pub const OPTION_IEN116_NAME_SERVERS: u32 = 5u32;
8951 pub const OPTION_IMPRESS_SERVERS: u32 = 10u32;
8952 pub const OPTION_KEEP_ALIVE_DATA_SIZE: u32 = 39u32;
8953 pub const OPTION_KEEP_ALIVE_INTERVAL: u32 = 38u32;
8954 pub const OPTION_LEASE_TIME: u32 = 51u32;
8955 pub const OPTION_LOG_SERVERS: u32 = 7u32;
8956 pub const OPTION_LPR_SERVERS: u32 = 9u32;
8957 pub const OPTION_MAX_REASSEMBLY_SIZE: u32 = 22u32;
8958 pub const OPTION_MERIT_DUMP_FILE: u32 = 14u32;
8959 pub const OPTION_MESSAGE: u32 = 56u32;
8960 pub const OPTION_MESSAGE_LENGTH: u32 = 57u32;
8961 pub const OPTION_MESSAGE_TYPE: u32 = 53u32;
8962 pub const OPTION_MSFT_IE_PROXY: u32 = 252u32;
8963 pub const OPTION_MTU: u32 = 26u32;
8964 pub const OPTION_NETBIOS_DATAGRAM_SERVER: u32 = 45u32;
8965 pub const OPTION_NETBIOS_NAME_SERVER: u32 = 44u32;
8966 pub const OPTION_NETBIOS_NODE_TYPE: u32 = 46u32;
8967 pub const OPTION_NETBIOS_SCOPE_OPTION: u32 = 47u32;
8968 pub const OPTION_NETWORK_INFO_SERVERS: u32 = 41u32;
8969 pub const OPTION_NETWORK_INFO_SERVICE_DOM: u32 = 40u32;
8970 pub const OPTION_NETWORK_TIME_SERVERS: u32 = 42u32;
8971 pub const OPTION_NON_LOCAL_SOURCE_ROUTING: u32 = 20u32;
8972 pub const OPTION_OK_TO_OVERLAY: u32 = 52u32;
8973 pub const OPTION_PAD: u32 = 0u32;
8974 pub const OPTION_PARAMETER_REQUEST_LIST: u32 = 55u32;
8975 pub const OPTION_PERFORM_MASK_DISCOVERY: u32 = 29u32;
8976 pub const OPTION_PERFORM_ROUTER_DISCOVERY: u32 = 31u32;
8977 pub const OPTION_PMTU_AGING_TIMEOUT: u32 = 24u32;
8978 pub const OPTION_PMTU_PLATEAU_TABLE: u32 = 25u32;
8979 pub const OPTION_POLICY_FILTER_FOR_NLSR: u32 = 21u32;
8980 pub const OPTION_REBIND_TIME: u32 = 59u32;
8981 pub const OPTION_RENEWAL_TIME: u32 = 58u32;
8982 pub const OPTION_REQUESTED_ADDRESS: u32 = 50u32;
8983 pub const OPTION_RLP_SERVERS: u32 = 11u32;
8984 pub const OPTION_ROOT_DISK: u32 = 17u32;
8985 pub const OPTION_ROUTER_ADDRESS: u32 = 3u32;
8986 pub const OPTION_ROUTER_SOLICITATION_ADDR: u32 = 32u32;
8987 pub const OPTION_SERVER_IDENTIFIER: u32 = 54u32;
8988 pub const OPTION_STATIC_ROUTES: u32 = 33u32;
8989 pub const OPTION_SUBNET_MASK: u32 = 1u32;
8990 pub const OPTION_SWAP_SERVER: u32 = 16u32;
8991 pub const OPTION_TFTP_SERVER_NAME: u32 = 66u32;
8992 pub const OPTION_TIME_OFFSET: u32 = 2u32;
8993 pub const OPTION_TIME_SERVERS: u32 = 4u32;
8994 pub const OPTION_TRAILERS: u32 = 34u32;
8995 pub const OPTION_TTL: u32 = 37u32;
8996 pub const OPTION_VENDOR_SPEC_INFO: u32 = 43u32;
8997 pub const OPTION_XWINDOW_DISPLAY_MANAGER: u32 = 49u32;
8998 pub const OPTION_XWINDOW_FONT_SERVER: u32 = 48u32;
8999 pub const PERCENTAGE: u32 = 8u32;
9000 pub const PREVSTATE: u32 = 32u32;
9001 pub const QUARANTINE_CONFIG_OPTION: u32 = 43222u32;
9002 pub const QUARANTINE_SCOPE_QUARPROFILE_OPTION: u32 = 43221u32;
9003 pub const QUARANTIN_OPTION_BASE: u32 = 43220u32;
9004 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9005 #[repr(transparent)]
9006 pub struct QuarantineStatus(pub i32);
9007 pub const NOQUARANTINE: QuarantineStatus = QuarantineStatus(0i32);
9008 pub const RESTRICTEDACCESS: QuarantineStatus = QuarantineStatus(1i32);
9009 pub const DROPPACKET: QuarantineStatus = QuarantineStatus(2i32);
9010 pub const PROBATION: QuarantineStatus = QuarantineStatus(3i32);
9011 pub const EXEMPT: QuarantineStatus = QuarantineStatus(4i32);
9012 pub const DEFAULTQUARSETTING: QuarantineStatus = QuarantineStatus(5i32);
9013 pub const NOQUARINFO: QuarantineStatus = QuarantineStatus(6i32);
9014 impl ::std::convert::From<i32> for QuarantineStatus {
from(value: i32) -> Self9015     fn from(value: i32) -> Self {
9016         Self(value)
9017     }
9018 }
9019 unsafe impl ::windows::runtime::Abi for QuarantineStatus {
9020     type Abi = Self;
9021     type DefaultType = Self;
9022 }
9023 pub const SAFEPERIOD: u32 = 2u32;
9024 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9025 #[repr(C)]
9026 pub struct SCOPE_MIB_INFO {
9027     pub Subnet: u32,
9028     pub NumAddressesInuse: u32,
9029     pub NumAddressesFree: u32,
9030     pub NumPendingOffers: u32,
9031 }
9032 impl SCOPE_MIB_INFO {}
9033 impl ::std::default::Default for SCOPE_MIB_INFO {
default() -> Self9034     fn default() -> Self {
9035         unsafe { ::std::mem::zeroed() }
9036     }
9037 }
9038 impl ::std::fmt::Debug for SCOPE_MIB_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9039     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9040         fmt.debug_struct("SCOPE_MIB_INFO").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingOffers", &self.NumPendingOffers).finish()
9041     }
9042 }
9043 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO {
eq(&self, other: &Self) -> bool9044     fn eq(&self, other: &Self) -> bool {
9045         self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers
9046     }
9047 }
9048 impl ::std::cmp::Eq for SCOPE_MIB_INFO {}
9049 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO {
9050     type Abi = Self;
9051     type DefaultType = Self;
9052 }
9053 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9054 #[repr(C)]
9055 pub struct SCOPE_MIB_INFO_V5 {
9056     pub Subnet: u32,
9057     pub NumAddressesInuse: u32,
9058     pub NumAddressesFree: u32,
9059     pub NumPendingOffers: u32,
9060 }
9061 impl SCOPE_MIB_INFO_V5 {}
9062 impl ::std::default::Default for SCOPE_MIB_INFO_V5 {
default() -> Self9063     fn default() -> Self {
9064         unsafe { ::std::mem::zeroed() }
9065     }
9066 }
9067 impl ::std::fmt::Debug for SCOPE_MIB_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9068     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9069         fmt.debug_struct("SCOPE_MIB_INFO_V5").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingOffers", &self.NumPendingOffers).finish()
9070     }
9071 }
9072 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_V5 {
eq(&self, other: &Self) -> bool9073     fn eq(&self, other: &Self) -> bool {
9074         self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers
9075     }
9076 }
9077 impl ::std::cmp::Eq for SCOPE_MIB_INFO_V5 {}
9078 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_V5 {
9079     type Abi = Self;
9080     type DefaultType = Self;
9081 }
9082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9083 #[repr(C)]
9084 pub struct SCOPE_MIB_INFO_V6 {
9085     pub Subnet: DHCP_IPV6_ADDRESS,
9086     pub NumAddressesInuse: u64,
9087     pub NumAddressesFree: u64,
9088     pub NumPendingAdvertises: u64,
9089 }
9090 impl SCOPE_MIB_INFO_V6 {}
9091 impl ::std::default::Default for SCOPE_MIB_INFO_V6 {
default() -> Self9092     fn default() -> Self {
9093         unsafe { ::std::mem::zeroed() }
9094     }
9095 }
9096 impl ::std::fmt::Debug for SCOPE_MIB_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9097     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9098         fmt.debug_struct("SCOPE_MIB_INFO_V6").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingAdvertises", &self.NumPendingAdvertises).finish()
9099     }
9100 }
9101 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_V6 {
eq(&self, other: &Self) -> bool9102     fn eq(&self, other: &Self) -> bool {
9103         self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingAdvertises == other.NumPendingAdvertises
9104     }
9105 }
9106 impl ::std::cmp::Eq for SCOPE_MIB_INFO_V6 {}
9107 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_V6 {
9108     type Abi = Self;
9109     type DefaultType = Self;
9110 }
9111 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9112 #[repr(C)]
9113 pub struct SCOPE_MIB_INFO_VQ {
9114     pub Subnet: u32,
9115     pub NumAddressesInuse: u32,
9116     pub NumAddressesFree: u32,
9117     pub NumPendingOffers: u32,
9118     pub QtnNumLeases: u32,
9119     pub QtnPctQtnLeases: u32,
9120     pub QtnProbationLeases: u32,
9121     pub QtnNonQtnLeases: u32,
9122     pub QtnExemptLeases: u32,
9123     pub QtnCapableClients: u32,
9124 }
9125 impl SCOPE_MIB_INFO_VQ {}
9126 impl ::std::default::Default for SCOPE_MIB_INFO_VQ {
default() -> Self9127     fn default() -> Self {
9128         unsafe { ::std::mem::zeroed() }
9129     }
9130 }
9131 impl ::std::fmt::Debug for SCOPE_MIB_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9132     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9133         fmt.debug_struct("SCOPE_MIB_INFO_VQ")
9134             .field("Subnet", &self.Subnet)
9135             .field("NumAddressesInuse", &self.NumAddressesInuse)
9136             .field("NumAddressesFree", &self.NumAddressesFree)
9137             .field("NumPendingOffers", &self.NumPendingOffers)
9138             .field("QtnNumLeases", &self.QtnNumLeases)
9139             .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
9140             .field("QtnProbationLeases", &self.QtnProbationLeases)
9141             .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
9142             .field("QtnExemptLeases", &self.QtnExemptLeases)
9143             .field("QtnCapableClients", &self.QtnCapableClients)
9144             .finish()
9145     }
9146 }
9147 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_VQ {
eq(&self, other: &Self) -> bool9148     fn eq(&self, other: &Self) -> bool {
9149         self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers && self.QtnNumLeases == other.QtnNumLeases && self.QtnPctQtnLeases == other.QtnPctQtnLeases && self.QtnProbationLeases == other.QtnProbationLeases && self.QtnNonQtnLeases == other.QtnNonQtnLeases && self.QtnExemptLeases == other.QtnExemptLeases && self.QtnCapableClients == other.QtnCapableClients
9150     }
9151 }
9152 impl ::std::cmp::Eq for SCOPE_MIB_INFO_VQ {}
9153 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_VQ {
9154     type Abi = Self;
9155     type DefaultType = Self;
9156 }
9157 pub const SHAREDSECRET: u32 = 64u32;
9158 pub const Set_APIProtocolSupport: u32 = 1u32;
9159 pub const Set_AuditLogState: u32 = 2048u32;
9160 pub const Set_BackupInterval: u32 = 16u32;
9161 pub const Set_BackupPath: u32 = 8u32;
9162 pub const Set_BootFileTable: u32 = 1024u32;
9163 pub const Set_DatabaseCleanupInterval: u32 = 128u32;
9164 pub const Set_DatabaseLoggingFlag: u32 = 32u32;
9165 pub const Set_DatabaseName: u32 = 2u32;
9166 pub const Set_DatabasePath: u32 = 4u32;
9167 pub const Set_DebugFlag: u32 = 256u32;
9168 pub const Set_PingRetries: u32 = 512u32;
9169 pub const Set_PreferredLifetime: u32 = 4u32;
9170 pub const Set_PreferredLifetimeIATA: u32 = 64u32;
9171 pub const Set_QuarantineDefFail: u32 = 8192u32;
9172 pub const Set_QuarantineON: u32 = 4096u32;
9173 pub const Set_RapidCommitFlag: u32 = 2u32;
9174 pub const Set_RestoreFlag: u32 = 64u32;
9175 pub const Set_T1: u32 = 16u32;
9176 pub const Set_T2: u32 = 32u32;
9177 pub const Set_UnicastFlag: u32 = 1u32;
9178 pub const Set_ValidLifetime: u32 = 8u32;
9179 pub const Set_ValidLifetimeIATA: u32 = 128u32;
9180 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9181 #[repr(transparent)]
9182 pub struct StatusCode(pub i32);
9183 pub const STATUS_NO_ERROR: StatusCode = StatusCode(0i32);
9184 pub const STATUS_UNSPECIFIED_FAILURE: StatusCode = StatusCode(1i32);
9185 pub const STATUS_NO_BINDING: StatusCode = StatusCode(3i32);
9186 pub const STATUS_NOPREFIX_AVAIL: StatusCode = StatusCode(6i32);
9187 impl ::std::convert::From<i32> for StatusCode {
from(value: i32) -> Self9188     fn from(value: i32) -> Self {
9189         Self(value)
9190     }
9191 }
9192 unsafe impl ::windows::runtime::Abi for StatusCode {
9193     type Abi = Self;
9194     type DefaultType = Self;
9195 }
9196 pub const V5_ADDRESS_BIT_BOTH_REC: u32 = 32u32;
9197 pub const V5_ADDRESS_BIT_DELETED: u32 = 128u32;
9198 pub const V5_ADDRESS_BIT_UNREGISTERED: u32 = 64u32;
9199 pub const V5_ADDRESS_EX_BIT_DISABLE_PTR_RR: u32 = 1u32;
9200 pub const V5_ADDRESS_STATE_ACTIVE: u32 = 1u32;
9201 pub const V5_ADDRESS_STATE_DECLINED: u32 = 2u32;
9202 pub const V5_ADDRESS_STATE_DOOM: u32 = 3u32;
9203 pub const V5_ADDRESS_STATE_OFFERED: u32 = 0u32;
9204 pub const WARNING_EXTENDED_LESS: i32 = 20026i32;
9205