]> git.proxmox.com Git - rustc.git/blame - vendor/windows/src/Windows/Win32/Storage/DistributedFileSystem/mod.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.70.0+dfsg1
[rustc.git] / vendor / windows / src / Windows / Win32 / Storage / DistributedFileSystem / mod.rs
CommitLineData
353b0b11
FG		 1#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
2#[inline]
3pub unsafe fn NetDfsAdd<P0, P1, P2, P3>(dfsentrypath: P0, servername: P1, sharename: P2, comment: P3, flags: u32) -> u32
4where
5 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
6 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
7 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
8 P3: ::windows::core::IntoParam<::windows::core::PCWSTR>,
9{
10 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsAdd ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR , comment : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
11 NetDfsAdd(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi(), comment.into_param().abi(), flags)
12}
13#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
14#[inline]
15pub unsafe fn NetDfsAddFtRoot<P0, P1, P2, P3>(servername: P0, rootshare: P1, ftdfsname: P2, comment: P3, flags: u32) -> u32
16where
17 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
18 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
19 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
20 P3: ::windows::core::IntoParam<::windows::core::PCWSTR>,
21{
22 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsAddFtRoot ( servername : :: windows::core::PCWSTR , rootshare : :: windows::core::PCWSTR , ftdfsname : :: windows::core::PCWSTR , comment : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
23 NetDfsAddFtRoot(servername.into_param().abi(), rootshare.into_param().abi(), ftdfsname.into_param().abi(), comment.into_param().abi(), flags)
24}
25#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
26#[inline]
27pub unsafe fn NetDfsAddRootTarget<P0, P1, P2>(pdfspath: P0, ptargetpath: P1, majorversion: u32, pcomment: P2, flags: u32) -> u32
28where
29 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
30 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
31 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
32{
33 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsAddRootTarget ( pdfspath : :: windows::core::PCWSTR , ptargetpath : :: windows::core::PCWSTR , majorversion : u32 , pcomment : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
34 NetDfsAddRootTarget(pdfspath.into_param().abi(), ptargetpath.into_param().abi(), majorversion, pcomment.into_param().abi(), flags)
35}
36#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
37#[inline]
38pub unsafe fn NetDfsAddStdRoot<P0, P1, P2>(servername: P0, rootshare: P1, comment: P2, flags: u32) -> u32
39where
40 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
41 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
42 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
43{
44 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsAddStdRoot ( servername : :: windows::core::PCWSTR , rootshare : :: windows::core::PCWSTR , comment : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
45 NetDfsAddStdRoot(servername.into_param().abi(), rootshare.into_param().abi(), comment.into_param().abi(), flags)
46}
47#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
48#[inline]
49pub unsafe fn NetDfsEnum<P0>(dfsname: P0, level: u32, prefmaxlen: u32, buffer: *mut *mut u8, entriesread: *mut u32, resumehandle: *mut u32) -> u32
50where
51 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
52{
53 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsEnum ( dfsname : :: windows::core::PCWSTR , level : u32 , prefmaxlen : u32 , buffer : *mut *mut u8 , entriesread : *mut u32 , resumehandle : *mut u32 ) -> u32 );
54 NetDfsEnum(dfsname.into_param().abi(), level, prefmaxlen, buffer, entriesread, resumehandle)
55}
56#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
57#[inline]
58pub unsafe fn NetDfsGetClientInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *mut *mut u8) -> u32
59where
60 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
61 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
62 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
63{
64 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetClientInfo ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR , level : u32 , buffer : *mut *mut u8 ) -> u32 );
65 NetDfsGetClientInfo(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi(), level, buffer)
66}
67#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
68#[cfg(feature = "Win32_Security")]
69#[inline]
70pub unsafe fn NetDfsGetFtContainerSecurity<P0>(domainname: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
71where
72 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
73{
74 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetFtContainerSecurity ( domainname : :: windows::core::PCWSTR , securityinformation : u32 , ppsecuritydescriptor : *mut super::super::Security:: PSECURITY_DESCRIPTOR , lpcbsecuritydescriptor : *mut u32 ) -> u32 );
75 NetDfsGetFtContainerSecurity(domainname.into_param().abi(), securityinformation, ppsecuritydescriptor, lpcbsecuritydescriptor)
76}
77#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
78#[inline]
79pub unsafe fn NetDfsGetInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *mut *mut u8) -> u32
80where
81 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
82 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
83 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
84{
85 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetInfo ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR , level : u32 , buffer : *mut *mut u8 ) -> u32 );
86 NetDfsGetInfo(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi(), level, buffer)
87}
88#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
89#[cfg(feature = "Win32_Security")]
90#[inline]
91pub unsafe fn NetDfsGetSecurity<P0>(dfsentrypath: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
92where
93 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
94{
95 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetSecurity ( dfsentrypath : :: windows::core::PCWSTR , securityinformation : u32 , ppsecuritydescriptor : *mut super::super::Security:: PSECURITY_DESCRIPTOR , lpcbsecuritydescriptor : *mut u32 ) -> u32 );
96 NetDfsGetSecurity(dfsentrypath.into_param().abi(), securityinformation, ppsecuritydescriptor, lpcbsecuritydescriptor)
97}
98#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
99#[cfg(feature = "Win32_Security")]
100#[inline]
101pub unsafe fn NetDfsGetStdContainerSecurity<P0>(machinename: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
102where
103 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
104{
105 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetStdContainerSecurity ( machinename : :: windows::core::PCWSTR , securityinformation : u32 , ppsecuritydescriptor : *mut super::super::Security:: PSECURITY_DESCRIPTOR , lpcbsecuritydescriptor : *mut u32 ) -> u32 );
106 NetDfsGetStdContainerSecurity(machinename.into_param().abi(), securityinformation, ppsecuritydescriptor, lpcbsecuritydescriptor)
107}
108#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
109#[inline]
110pub unsafe fn NetDfsGetSupportedNamespaceVersion<P0>(origin: DFS_NAMESPACE_VERSION_ORIGIN, pname: P0, ppversioninfo: *mut *mut DFS_SUPPORTED_NAMESPACE_VERSION_INFO) -> u32
111where
112 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
113{
114 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsGetSupportedNamespaceVersion ( origin : DFS_NAMESPACE_VERSION_ORIGIN , pname : :: windows::core::PCWSTR , ppversioninfo : *mut *mut DFS_SUPPORTED_NAMESPACE_VERSION_INFO ) -> u32 );
115 NetDfsGetSupportedNamespaceVersion(origin, pname.into_param().abi(), ppversioninfo)
116}
117#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
118#[inline]
119pub unsafe fn NetDfsMove<P0, P1>(olddfsentrypath: P0, newdfsentrypath: P1, flags: u32) -> u32
120where
121 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
122 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
123{
124 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsMove ( olddfsentrypath : :: windows::core::PCWSTR , newdfsentrypath : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
125 NetDfsMove(olddfsentrypath.into_param().abi(), newdfsentrypath.into_param().abi(), flags)
126}
127#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
128#[inline]
129pub unsafe fn NetDfsRemove<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2) -> u32
130where
131 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
132 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
133 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
134{
135 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsRemove ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR ) -> u32 );
136 NetDfsRemove(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi())
137}
138#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
139#[inline]
140pub unsafe fn NetDfsRemoveFtRoot<P0, P1, P2>(servername: P0, rootshare: P1, ftdfsname: P2, flags: u32) -> u32
141where
142 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
143 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
144 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
145{
146 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsRemoveFtRoot ( servername : :: windows::core::PCWSTR , rootshare : :: windows::core::PCWSTR , ftdfsname : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
147 NetDfsRemoveFtRoot(servername.into_param().abi(), rootshare.into_param().abi(), ftdfsname.into_param().abi(), flags)
148}
149#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
150#[inline]
151pub unsafe fn NetDfsRemoveFtRootForced<P0, P1, P2, P3>(domainname: P0, servername: P1, rootshare: P2, ftdfsname: P3, flags: u32) -> u32
152where
153 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
154 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
155 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
156 P3: ::windows::core::IntoParam<::windows::core::PCWSTR>,
157{
158 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsRemoveFtRootForced ( domainname : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , rootshare : :: windows::core::PCWSTR , ftdfsname : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
159 NetDfsRemoveFtRootForced(domainname.into_param().abi(), servername.into_param().abi(), rootshare.into_param().abi(), ftdfsname.into_param().abi(), flags)
160}
161#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
162#[inline]
163pub unsafe fn NetDfsRemoveRootTarget<P0, P1>(pdfspath: P0, ptargetpath: P1, flags: u32) -> u32
164where
165 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
166 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
167{
168 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsRemoveRootTarget ( pdfspath : :: windows::core::PCWSTR , ptargetpath : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
169 NetDfsRemoveRootTarget(pdfspath.into_param().abi(), ptargetpath.into_param().abi(), flags)
170}
171#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
172#[inline]
173pub unsafe fn NetDfsRemoveStdRoot<P0, P1>(servername: P0, rootshare: P1, flags: u32) -> u32
174where
175 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
176 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
177{
178 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsRemoveStdRoot ( servername : :: windows::core::PCWSTR , rootshare : :: windows::core::PCWSTR , flags : u32 ) -> u32 );
179 NetDfsRemoveStdRoot(servername.into_param().abi(), rootshare.into_param().abi(), flags)
180}
181#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
182#[inline]
183pub unsafe fn NetDfsSetClientInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *const u8) -> u32
184where
185 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
186 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
187 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
188{
189 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsSetClientInfo ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR , level : u32 , buffer : *const u8 ) -> u32 );
190 NetDfsSetClientInfo(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi(), level, buffer)
191}
192#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
193#[cfg(feature = "Win32_Security")]
194#[inline]
195pub unsafe fn NetDfsSetFtContainerSecurity<P0, P1>(domainname: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
196where
197 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
198 P1: ::windows::core::IntoParam<super::super::Security::PSECURITY_DESCRIPTOR>,
199{
200 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsSetFtContainerSecurity ( domainname : :: windows::core::PCWSTR , securityinformation : u32 , psecuritydescriptor : super::super::Security:: PSECURITY_DESCRIPTOR ) -> u32 );
201 NetDfsSetFtContainerSecurity(domainname.into_param().abi(), securityinformation, psecuritydescriptor.into_param().abi())
202}
203#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
204#[inline]
205pub unsafe fn NetDfsSetInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *const u8) -> u32
206where
207 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
208 P1: ::windows::core::IntoParam<::windows::core::PCWSTR>,
209 P2: ::windows::core::IntoParam<::windows::core::PCWSTR>,
210{
211 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsSetInfo ( dfsentrypath : :: windows::core::PCWSTR , servername : :: windows::core::PCWSTR , sharename : :: windows::core::PCWSTR , level : u32 , buffer : *const u8 ) -> u32 );
212 NetDfsSetInfo(dfsentrypath.into_param().abi(), servername.into_param().abi(), sharename.into_param().abi(), level, buffer)
213}
214#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
215#[cfg(feature = "Win32_Security")]
216#[inline]
217pub unsafe fn NetDfsSetSecurity<P0, P1>(dfsentrypath: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
218where
219 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
220 P1: ::windows::core::IntoParam<super::super::Security::PSECURITY_DESCRIPTOR>,
221{
222 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsSetSecurity ( dfsentrypath : :: windows::core::PCWSTR , securityinformation : u32 , psecuritydescriptor : super::super::Security:: PSECURITY_DESCRIPTOR ) -> u32 );
223 NetDfsSetSecurity(dfsentrypath.into_param().abi(), securityinformation, psecuritydescriptor.into_param().abi())
224}
225#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
226#[cfg(feature = "Win32_Security")]
227#[inline]
228pub unsafe fn NetDfsSetStdContainerSecurity<P0, P1>(machinename: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
229where
230 P0: ::windows::core::IntoParam<::windows::core::PCWSTR>,
231 P1: ::windows::core::IntoParam<super::super::Security::PSECURITY_DESCRIPTOR>,
232{
233 ::windows::imp::link ! ( "netapi32.dll""system" fn NetDfsSetStdContainerSecurity ( machinename : :: windows::core::PCWSTR , securityinformation : u32 , psecuritydescriptor : super::super::Security:: PSECURITY_DESCRIPTOR ) -> u32 );
234 NetDfsSetStdContainerSecurity(machinename.into_param().abi(), securityinformation, psecuritydescriptor.into_param().abi())
235}
236#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
237pub const DFS_ADD_VOLUME: u32 = 1u32;
238#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
239pub const DFS_FORCE_REMOVE: u32 = 2147483648u32;
240#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
241pub const DFS_MOVE_FLAG_REPLACE_IF_EXISTS: u32 = 1u32;
242#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
243pub const DFS_PROPERTY_FLAG_ABDE: u32 = 32u32;
244#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
245pub const DFS_PROPERTY_FLAG_CLUSTER_ENABLED: u32 = 16u32;
246#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
247pub const DFS_PROPERTY_FLAG_INSITE_REFERRALS: u32 = 1u32;
248#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
249pub const DFS_PROPERTY_FLAG_ROOT_SCALABILITY: u32 = 2u32;
250#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
251pub const DFS_PROPERTY_FLAG_SITE_COSTING: u32 = 4u32;
252#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
253pub const DFS_PROPERTY_FLAG_TARGET_FAILBACK: u32 = 8u32;
254#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
255pub const DFS_RESTORE_VOLUME: u32 = 2u32;
256#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
257pub const DFS_SITE_PRIMARY: u32 = 1u32;
258#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
259pub const DFS_STORAGE_FLAVOR_UNUSED2: u32 = 768u32;
260#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
261pub const DFS_STORAGE_STATES: u32 = 15u32;
262#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
263pub const DFS_STORAGE_STATE_ACTIVE: u32 = 4u32;
264#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
265pub const DFS_STORAGE_STATE_OFFLINE: u32 = 1u32;
266#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
267pub const DFS_STORAGE_STATE_ONLINE: u32 = 2u32;
268#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
269pub const DFS_VOLUME_FLAVORS: u32 = 768u32;
270#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
271pub const DFS_VOLUME_FLAVOR_AD_BLOB: u32 = 512u32;
272#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
273pub const DFS_VOLUME_FLAVOR_STANDALONE: u32 = 256u32;
274#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
275pub const DFS_VOLUME_FLAVOR_UNUSED1: u32 = 0u32;
276#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
277pub const DFS_VOLUME_STATES: u32 = 15u32;
278#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
279pub const DFS_VOLUME_STATE_FORCE_SYNC: u32 = 64u32;
280#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
281pub const DFS_VOLUME_STATE_INCONSISTENT: u32 = 2u32;
282#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
283pub const DFS_VOLUME_STATE_OFFLINE: u32 = 3u32;
284#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
285pub const DFS_VOLUME_STATE_OK: u32 = 1u32;
286#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
287pub const DFS_VOLUME_STATE_ONLINE: u32 = 4u32;
288#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
289pub const DFS_VOLUME_STATE_RESYNCHRONIZE: u32 = 16u32;
290#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
291pub const DFS_VOLUME_STATE_STANDBY: u32 = 32u32;
292#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
293pub const FSCTL_DFS_BASE: u32 = 6u32;
294#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
295pub const FSCTL_DFS_GET_PKT_ENTRY_STATE: u32 = 401340u32;
296#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
297pub const NET_DFS_SETDC_FLAGS: u32 = 0u32;
298#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
299pub const NET_DFS_SETDC_INITPKT: u32 = 2u32;
300#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
301pub const NET_DFS_SETDC_TIMEOUT: u32 = 1u32;
302#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
303#[repr(transparent)]
304#[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
305pub struct DFS_NAMESPACE_VERSION_ORIGIN(pub i32);
306#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
307pub const DFS_NAMESPACE_VERSION_ORIGIN_COMBINED: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(0i32);
308#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
309pub const DFS_NAMESPACE_VERSION_ORIGIN_SERVER: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(1i32);
310#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
311pub const DFS_NAMESPACE_VERSION_ORIGIN_DOMAIN: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(2i32);
312impl ::core::marker::Copy for DFS_NAMESPACE_VERSION_ORIGIN {}
313impl ::core::clone::Clone for DFS_NAMESPACE_VERSION_ORIGIN {
314 fn clone(&self) -> Self {
315 *self
316 }
317}
318impl ::core::default::Default for DFS_NAMESPACE_VERSION_ORIGIN {
319 fn default() -> Self {
320 Self(0)
321 }
322}
323impl ::windows::core::TypeKind for DFS_NAMESPACE_VERSION_ORIGIN {
324 type TypeKind = ::windows::core::CopyType;
325}
326impl ::core::fmt::Debug for DFS_NAMESPACE_VERSION_ORIGIN {
327 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
328 f.debug_tuple("DFS_NAMESPACE_VERSION_ORIGIN").field(&self.0).finish()
329 }
330}
331#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
332#[repr(transparent)]
333#[derive(::core::cmp::PartialEq, ::core::cmp::Eq)]
334pub struct DFS_TARGET_PRIORITY_CLASS(pub i32);
335#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
336pub const DfsInvalidPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(-1i32);
337#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
338pub const DfsSiteCostNormalPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(0i32);
339#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
340pub const DfsGlobalHighPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(1i32);
341#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
342pub const DfsSiteCostHighPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(2i32);
343#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
344pub const DfsSiteCostLowPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(3i32);
345#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
346pub const DfsGlobalLowPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(4i32);
347impl ::core::marker::Copy for DFS_TARGET_PRIORITY_CLASS {}
348impl ::core::clone::Clone for DFS_TARGET_PRIORITY_CLASS {
349 fn clone(&self) -> Self {
350 *self
351 }
352}
353impl ::core::default::Default for DFS_TARGET_PRIORITY_CLASS {
354 fn default() -> Self {
355 Self(0)
356 }
357}
358impl ::windows::core::TypeKind for DFS_TARGET_PRIORITY_CLASS {
359 type TypeKind = ::windows::core::CopyType;
360}
361impl ::core::fmt::Debug for DFS_TARGET_PRIORITY_CLASS {
362 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
363 f.debug_tuple("DFS_TARGET_PRIORITY_CLASS").field(&self.0).finish()
364 }
365}
366#[repr(C)]
367#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
368pub struct DFS_GET_PKT_ENTRY_STATE_ARG {
369 pub DfsEntryPathLen: u16,
370 pub ServerNameLen: u16,
371 pub ShareNameLen: u16,
372 pub Level: u32,
373 pub Buffer: [u16; 1],
374}
375impl ::core::marker::Copy for DFS_GET_PKT_ENTRY_STATE_ARG {}
376impl ::core::clone::Clone for DFS_GET_PKT_ENTRY_STATE_ARG {
377 fn clone(&self) -> Self {
378 *self
379 }
380}
381impl ::core::fmt::Debug for DFS_GET_PKT_ENTRY_STATE_ARG {
382 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
383 f.debug_struct("DFS_GET_PKT_ENTRY_STATE_ARG").field("DfsEntryPathLen", &self.DfsEntryPathLen).field("ServerNameLen", &self.ServerNameLen).field("ShareNameLen", &self.ShareNameLen).field("Level", &self.Level).field("Buffer", &self.Buffer).finish()
384 }
385}
386impl ::windows::core::TypeKind for DFS_GET_PKT_ENTRY_STATE_ARG {
387 type TypeKind = ::windows::core::CopyType;
388}
389impl ::core::cmp::PartialEq for DFS_GET_PKT_ENTRY_STATE_ARG {
390 fn eq(&self, other: &Self) -> bool {
391 self.DfsEntryPathLen == other.DfsEntryPathLen && self.ServerNameLen == other.ServerNameLen && self.ShareNameLen == other.ShareNameLen && self.Level == other.Level && self.Buffer == other.Buffer
392 }
393}
394impl ::core::cmp::Eq for DFS_GET_PKT_ENTRY_STATE_ARG {}
395impl ::core::default::Default for DFS_GET_PKT_ENTRY_STATE_ARG {
396 fn default() -> Self {
397 unsafe { ::core::mem::zeroed() }
398 }
399}
400#[repr(C)]
401#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
402pub struct DFS_INFO_1 {
403 pub EntryPath: ::windows::core::PWSTR,
404}
405impl ::core::marker::Copy for DFS_INFO_1 {}
406impl ::core::clone::Clone for DFS_INFO_1 {
407 fn clone(&self) -> Self {
408 *self
409 }
410}
411impl ::core::fmt::Debug for DFS_INFO_1 {
412 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
413 f.debug_struct("DFS_INFO_1").field("EntryPath", &self.EntryPath).finish()
414 }
415}
416impl ::windows::core::TypeKind for DFS_INFO_1 {
417 type TypeKind = ::windows::core::CopyType;
418}
419impl ::core::cmp::PartialEq for DFS_INFO_1 {
420 fn eq(&self, other: &Self) -> bool {
421 self.EntryPath == other.EntryPath
422 }
423}
424impl ::core::cmp::Eq for DFS_INFO_1 {}
425impl ::core::default::Default for DFS_INFO_1 {
426 fn default() -> Self {
427 unsafe { ::core::mem::zeroed() }
428 }
429}
430#[repr(C)]
431#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
432pub struct DFS_INFO_100 {
433 pub Comment: ::windows::core::PWSTR,
434}
435impl ::core::marker::Copy for DFS_INFO_100 {}
436impl ::core::clone::Clone for DFS_INFO_100 {
437 fn clone(&self) -> Self {
438 *self
439 }
440}
441impl ::core::fmt::Debug for DFS_INFO_100 {
442 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
443 f.debug_struct("DFS_INFO_100").field("Comment", &self.Comment).finish()
444 }
445}
446impl ::windows::core::TypeKind for DFS_INFO_100 {
447 type TypeKind = ::windows::core::CopyType;
448}
449impl ::core::cmp::PartialEq for DFS_INFO_100 {
450 fn eq(&self, other: &Self) -> bool {
451 self.Comment == other.Comment
452 }
453}
454impl ::core::cmp::Eq for DFS_INFO_100 {}
455impl ::core::default::Default for DFS_INFO_100 {
456 fn default() -> Self {
457 unsafe { ::core::mem::zeroed() }
458 }
459}
460#[repr(C)]
461#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
462pub struct DFS_INFO_101 {
463 pub State: u32,
464}
465impl ::core::marker::Copy for DFS_INFO_101 {}
466impl ::core::clone::Clone for DFS_INFO_101 {
467 fn clone(&self) -> Self {
468 *self
469 }
470}
471impl ::core::fmt::Debug for DFS_INFO_101 {
472 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
473 f.debug_struct("DFS_INFO_101").field("State", &self.State).finish()
474 }
475}
476impl ::windows::core::TypeKind for DFS_INFO_101 {
477 type TypeKind = ::windows::core::CopyType;
478}
479impl ::core::cmp::PartialEq for DFS_INFO_101 {
480 fn eq(&self, other: &Self) -> bool {
481 self.State == other.State
482 }
483}
484impl ::core::cmp::Eq for DFS_INFO_101 {}
485impl ::core::default::Default for DFS_INFO_101 {
486 fn default() -> Self {
487 unsafe { ::core::mem::zeroed() }
488 }
489}
490#[repr(C)]
491#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
492pub struct DFS_INFO_102 {
493 pub Timeout: u32,
494}
495impl ::core::marker::Copy for DFS_INFO_102 {}
496impl ::core::clone::Clone for DFS_INFO_102 {
497 fn clone(&self) -> Self {
498 *self
499 }
500}
501impl ::core::fmt::Debug for DFS_INFO_102 {
502 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
503 f.debug_struct("DFS_INFO_102").field("Timeout", &self.Timeout).finish()
504 }
505}
506impl ::windows::core::TypeKind for DFS_INFO_102 {
507 type TypeKind = ::windows::core::CopyType;
508}
509impl ::core::cmp::PartialEq for DFS_INFO_102 {
510 fn eq(&self, other: &Self) -> bool {
511 self.Timeout == other.Timeout
512 }
513}
514impl ::core::cmp::Eq for DFS_INFO_102 {}
515impl ::core::default::Default for DFS_INFO_102 {
516 fn default() -> Self {
517 unsafe { ::core::mem::zeroed() }
518 }
519}
520#[repr(C)]
521#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
522pub struct DFS_INFO_103 {
523 pub PropertyFlagMask: u32,
524 pub PropertyFlags: u32,
525}
526impl ::core::marker::Copy for DFS_INFO_103 {}
527impl ::core::clone::Clone for DFS_INFO_103 {
528 fn clone(&self) -> Self {
529 *self
530 }
531}
532impl ::core::fmt::Debug for DFS_INFO_103 {
533 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
534 f.debug_struct("DFS_INFO_103").field("PropertyFlagMask", &self.PropertyFlagMask).field("PropertyFlags", &self.PropertyFlags).finish()
535 }
536}
537impl ::windows::core::TypeKind for DFS_INFO_103 {
538 type TypeKind = ::windows::core::CopyType;
539}
540impl ::core::cmp::PartialEq for DFS_INFO_103 {
541 fn eq(&self, other: &Self) -> bool {
542 self.PropertyFlagMask == other.PropertyFlagMask && self.PropertyFlags == other.PropertyFlags
543 }
544}
545impl ::core::cmp::Eq for DFS_INFO_103 {}
546impl ::core::default::Default for DFS_INFO_103 {
547 fn default() -> Self {
548 unsafe { ::core::mem::zeroed() }
549 }
550}
551#[repr(C)]
552#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
553pub struct DFS_INFO_104 {
554 pub TargetPriority: DFS_TARGET_PRIORITY,
555}
556impl ::core::marker::Copy for DFS_INFO_104 {}
557impl ::core::clone::Clone for DFS_INFO_104 {
558 fn clone(&self) -> Self {
559 *self
560 }
561}
562impl ::core::fmt::Debug for DFS_INFO_104 {
563 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
564 f.debug_struct("DFS_INFO_104").field("TargetPriority", &self.TargetPriority).finish()
565 }
566}
567impl ::windows::core::TypeKind for DFS_INFO_104 {
568 type TypeKind = ::windows::core::CopyType;
569}
570impl ::core::cmp::PartialEq for DFS_INFO_104 {
571 fn eq(&self, other: &Self) -> bool {
572 self.TargetPriority == other.TargetPriority
573 }
574}
575impl ::core::cmp::Eq for DFS_INFO_104 {}
576impl ::core::default::Default for DFS_INFO_104 {
577 fn default() -> Self {
578 unsafe { ::core::mem::zeroed() }
579 }
580}
581#[repr(C)]
582#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
583pub struct DFS_INFO_105 {
584 pub Comment: ::windows::core::PWSTR,
585 pub State: u32,
586 pub Timeout: u32,
587 pub PropertyFlagMask: u32,
588 pub PropertyFlags: u32,
589}
590impl ::core::marker::Copy for DFS_INFO_105 {}
591impl ::core::clone::Clone for DFS_INFO_105 {
592 fn clone(&self) -> Self {
593 *self
594 }
595}
596impl ::core::fmt::Debug for DFS_INFO_105 {
597 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
598 f.debug_struct("DFS_INFO_105").field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("PropertyFlagMask", &self.PropertyFlagMask).field("PropertyFlags", &self.PropertyFlags).finish()
599 }
600}
601impl ::windows::core::TypeKind for DFS_INFO_105 {
602 type TypeKind = ::windows::core::CopyType;
603}
604impl ::core::cmp::PartialEq for DFS_INFO_105 {
605 fn eq(&self, other: &Self) -> bool {
606 self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.PropertyFlagMask == other.PropertyFlagMask && self.PropertyFlags == other.PropertyFlags
607 }
608}
609impl ::core::cmp::Eq for DFS_INFO_105 {}
610impl ::core::default::Default for DFS_INFO_105 {
611 fn default() -> Self {
612 unsafe { ::core::mem::zeroed() }
613 }
614}
615#[repr(C)]
616#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
617pub struct DFS_INFO_106 {
618 pub State: u32,
619 pub TargetPriority: DFS_TARGET_PRIORITY,
620}
621impl ::core::marker::Copy for DFS_INFO_106 {}
622impl ::core::clone::Clone for DFS_INFO_106 {
623 fn clone(&self) -> Self {
624 *self
625 }
626}
627impl ::core::fmt::Debug for DFS_INFO_106 {
628 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
629 f.debug_struct("DFS_INFO_106").field("State", &self.State).field("TargetPriority", &self.TargetPriority).finish()
630 }
631}
632impl ::windows::core::TypeKind for DFS_INFO_106 {
633 type TypeKind = ::windows::core::CopyType;
634}
635impl ::core::cmp::PartialEq for DFS_INFO_106 {
636 fn eq(&self, other: &Self) -> bool {
637 self.State == other.State && self.TargetPriority == other.TargetPriority
638 }
639}
640impl ::core::cmp::Eq for DFS_INFO_106 {}
641impl ::core::default::Default for DFS_INFO_106 {
642 fn default() -> Self {
643 unsafe { ::core::mem::zeroed() }
644 }
645}
646#[repr(C)]
647#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
648#[cfg(feature = "Win32_Security")]
649pub struct DFS_INFO_107 {
650 pub Comment: ::windows::core::PWSTR,
651 pub State: u32,
652 pub Timeout: u32,
653 pub PropertyFlagMask: u32,
654 pub PropertyFlags: u32,
655 pub SdLengthReserved: u32,
656 pub pSecurityDescriptor: super::super::Security::PSECURITY_DESCRIPTOR,
657}
658#[cfg(feature = "Win32_Security")]
659impl ::core::marker::Copy for DFS_INFO_107 {}
660#[cfg(feature = "Win32_Security")]
661impl ::core::clone::Clone for DFS_INFO_107 {
662 fn clone(&self) -> Self {
663 *self
664 }
665}
666#[cfg(feature = "Win32_Security")]
667impl ::core::fmt::Debug for DFS_INFO_107 {
668 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
669 f.debug_struct("DFS_INFO_107").field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("PropertyFlagMask", &self.PropertyFlagMask).field("PropertyFlags", &self.PropertyFlags).field("SdLengthReserved", &self.SdLengthReserved).field("pSecurityDescriptor", &self.pSecurityDescriptor).finish()
670 }
671}
672#[cfg(feature = "Win32_Security")]
673impl ::windows::core::TypeKind for DFS_INFO_107 {
674 type TypeKind = ::windows::core::CopyType;
675}
676#[cfg(feature = "Win32_Security")]
677impl ::core::cmp::PartialEq for DFS_INFO_107 {
678 fn eq(&self, other: &Self) -> bool {
679 self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.PropertyFlagMask == other.PropertyFlagMask && self.PropertyFlags == other.PropertyFlags && self.SdLengthReserved == other.SdLengthReserved && self.pSecurityDescriptor == other.pSecurityDescriptor
680 }
681}
682#[cfg(feature = "Win32_Security")]
683impl ::core::cmp::Eq for DFS_INFO_107 {}
684#[cfg(feature = "Win32_Security")]
685impl ::core::default::Default for DFS_INFO_107 {
686 fn default() -> Self {
687 unsafe { ::core::mem::zeroed() }
688 }
689}
690#[repr(C)]
691#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
692#[cfg(feature = "Win32_Security")]
693pub struct DFS_INFO_150 {
694 pub SdLengthReserved: u32,
695 pub pSecurityDescriptor: super::super::Security::PSECURITY_DESCRIPTOR,
696}
697#[cfg(feature = "Win32_Security")]
698impl ::core::marker::Copy for DFS_INFO_150 {}
699#[cfg(feature = "Win32_Security")]
700impl ::core::clone::Clone for DFS_INFO_150 {
701 fn clone(&self) -> Self {
702 *self
703 }
704}
705#[cfg(feature = "Win32_Security")]
706impl ::core::fmt::Debug for DFS_INFO_150 {
707 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
708 f.debug_struct("DFS_INFO_150").field("SdLengthReserved", &self.SdLengthReserved).field("pSecurityDescriptor", &self.pSecurityDescriptor).finish()
709 }
710}
711#[cfg(feature = "Win32_Security")]
712impl ::windows::core::TypeKind for DFS_INFO_150 {
713 type TypeKind = ::windows::core::CopyType;
714}
715#[cfg(feature = "Win32_Security")]
716impl ::core::cmp::PartialEq for DFS_INFO_150 {
717 fn eq(&self, other: &Self) -> bool {
718 self.SdLengthReserved == other.SdLengthReserved && self.pSecurityDescriptor == other.pSecurityDescriptor
719 }
720}
721#[cfg(feature = "Win32_Security")]
722impl ::core::cmp::Eq for DFS_INFO_150 {}
723#[cfg(feature = "Win32_Security")]
724impl ::core::default::Default for DFS_INFO_150 {
725 fn default() -> Self {
726 unsafe { ::core::mem::zeroed() }
727 }
728}
729#[repr(C)]
730#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
731#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
732pub struct DFS_INFO_1_32 {
733 pub EntryPath: u32,
734}
735#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
736impl ::core::marker::Copy for DFS_INFO_1_32 {}
737#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
738impl ::core::clone::Clone for DFS_INFO_1_32 {
739 fn clone(&self) -> Self {
740 *self
741 }
742}
743#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
744impl ::core::fmt::Debug for DFS_INFO_1_32 {
745 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
746 f.debug_struct("DFS_INFO_1_32").field("EntryPath", &self.EntryPath).finish()
747 }
748}
749#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
750impl ::windows::core::TypeKind for DFS_INFO_1_32 {
751 type TypeKind = ::windows::core::CopyType;
752}
753#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
754impl ::core::cmp::PartialEq for DFS_INFO_1_32 {
755 fn eq(&self, other: &Self) -> bool {
756 self.EntryPath == other.EntryPath
757 }
758}
759#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
760impl ::core::cmp::Eq for DFS_INFO_1_32 {}
761#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
762impl ::core::default::Default for DFS_INFO_1_32 {
763 fn default() -> Self {
764 unsafe { ::core::mem::zeroed() }
765 }
766}
767#[repr(C)]
768#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
769pub struct DFS_INFO_2 {
770 pub EntryPath: ::windows::core::PWSTR,
771 pub Comment: ::windows::core::PWSTR,
772 pub State: u32,
773 pub NumberOfStorages: u32,
774}
775impl ::core::marker::Copy for DFS_INFO_2 {}
776impl ::core::clone::Clone for DFS_INFO_2 {
777 fn clone(&self) -> Self {
778 *self
779 }
780}
781impl ::core::fmt::Debug for DFS_INFO_2 {
782 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
783 f.debug_struct("DFS_INFO_2").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("NumberOfStorages", &self.NumberOfStorages).finish()
784 }
785}
786impl ::windows::core::TypeKind for DFS_INFO_2 {
787 type TypeKind = ::windows::core::CopyType;
788}
789impl ::core::cmp::PartialEq for DFS_INFO_2 {
790 fn eq(&self, other: &Self) -> bool {
791 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.NumberOfStorages == other.NumberOfStorages
792 }
793}
794impl ::core::cmp::Eq for DFS_INFO_2 {}
795impl ::core::default::Default for DFS_INFO_2 {
796 fn default() -> Self {
797 unsafe { ::core::mem::zeroed() }
798 }
799}
800#[repr(C)]
801#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
802pub struct DFS_INFO_200 {
803 pub FtDfsName: ::windows::core::PWSTR,
804}
805impl ::core::marker::Copy for DFS_INFO_200 {}
806impl ::core::clone::Clone for DFS_INFO_200 {
807 fn clone(&self) -> Self {
808 *self
809 }
810}
811impl ::core::fmt::Debug for DFS_INFO_200 {
812 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
813 f.debug_struct("DFS_INFO_200").field("FtDfsName", &self.FtDfsName).finish()
814 }
815}
816impl ::windows::core::TypeKind for DFS_INFO_200 {
817 type TypeKind = ::windows::core::CopyType;
818}
819impl ::core::cmp::PartialEq for DFS_INFO_200 {
820 fn eq(&self, other: &Self) -> bool {
821 self.FtDfsName == other.FtDfsName
822 }
823}
824impl ::core::cmp::Eq for DFS_INFO_200 {}
825impl ::core::default::Default for DFS_INFO_200 {
826 fn default() -> Self {
827 unsafe { ::core::mem::zeroed() }
828 }
829}
830#[repr(C)]
831#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
832#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
833pub struct DFS_INFO_2_32 {
834 pub EntryPath: u32,
835 pub Comment: u32,
836 pub State: u32,
837 pub NumberOfStorages: u32,
838}
839#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
840impl ::core::marker::Copy for DFS_INFO_2_32 {}
841#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
842impl ::core::clone::Clone for DFS_INFO_2_32 {
843 fn clone(&self) -> Self {
844 *self
845 }
846}
847#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
848impl ::core::fmt::Debug for DFS_INFO_2_32 {
849 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
850 f.debug_struct("DFS_INFO_2_32").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("NumberOfStorages", &self.NumberOfStorages).finish()
851 }
852}
853#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
854impl ::windows::core::TypeKind for DFS_INFO_2_32 {
855 type TypeKind = ::windows::core::CopyType;
856}
857#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
858impl ::core::cmp::PartialEq for DFS_INFO_2_32 {
859 fn eq(&self, other: &Self) -> bool {
860 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.NumberOfStorages == other.NumberOfStorages
861 }
862}
863#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
864impl ::core::cmp::Eq for DFS_INFO_2_32 {}
865#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
866impl ::core::default::Default for DFS_INFO_2_32 {
867 fn default() -> Self {
868 unsafe { ::core::mem::zeroed() }
869 }
870}
871#[repr(C)]
872#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
873pub struct DFS_INFO_3 {
874 pub EntryPath: ::windows::core::PWSTR,
875 pub Comment: ::windows::core::PWSTR,
876 pub State: u32,
877 pub NumberOfStorages: u32,
878 pub Storage: *mut DFS_STORAGE_INFO,
879}
880impl ::core::marker::Copy for DFS_INFO_3 {}
881impl ::core::clone::Clone for DFS_INFO_3 {
882 fn clone(&self) -> Self {
883 *self
884 }
885}
886impl ::core::fmt::Debug for DFS_INFO_3 {
887 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
888 f.debug_struct("DFS_INFO_3").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
889 }
890}
891impl ::windows::core::TypeKind for DFS_INFO_3 {
892 type TypeKind = ::windows::core::CopyType;
893}
894impl ::core::cmp::PartialEq for DFS_INFO_3 {
895 fn eq(&self, other: &Self) -> bool {
896 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
897 }
898}
899impl ::core::cmp::Eq for DFS_INFO_3 {}
900impl ::core::default::Default for DFS_INFO_3 {
901 fn default() -> Self {
902 unsafe { ::core::mem::zeroed() }
903 }
904}
905#[repr(C)]
906#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
907pub struct DFS_INFO_300 {
908 pub Flags: u32,
909 pub DfsName: ::windows::core::PWSTR,
910}
911impl ::core::marker::Copy for DFS_INFO_300 {}
912impl ::core::clone::Clone for DFS_INFO_300 {
913 fn clone(&self) -> Self {
914 *self
915 }
916}
917impl ::core::fmt::Debug for DFS_INFO_300 {
918 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
919 f.debug_struct("DFS_INFO_300").field("Flags", &self.Flags).field("DfsName", &self.DfsName).finish()
920 }
921}
922impl ::windows::core::TypeKind for DFS_INFO_300 {
923 type TypeKind = ::windows::core::CopyType;
924}
925impl ::core::cmp::PartialEq for DFS_INFO_300 {
926 fn eq(&self, other: &Self) -> bool {
927 self.Flags == other.Flags && self.DfsName == other.DfsName
928 }
929}
930impl ::core::cmp::Eq for DFS_INFO_300 {}
931impl ::core::default::Default for DFS_INFO_300 {
932 fn default() -> Self {
933 unsafe { ::core::mem::zeroed() }
934 }
935}
936#[repr(C)]
937#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
938#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
939pub struct DFS_INFO_3_32 {
940 pub EntryPath: u32,
941 pub Comment: u32,
942 pub State: u32,
943 pub NumberOfStorages: u32,
944 pub Storage: u32,
945}
946#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
947impl ::core::marker::Copy for DFS_INFO_3_32 {}
948#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
949impl ::core::clone::Clone for DFS_INFO_3_32 {
950 fn clone(&self) -> Self {
951 *self
952 }
953}
954#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
955impl ::core::fmt::Debug for DFS_INFO_3_32 {
956 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
957 f.debug_struct("DFS_INFO_3_32").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
958 }
959}
960#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
961impl ::windows::core::TypeKind for DFS_INFO_3_32 {
962 type TypeKind = ::windows::core::CopyType;
963}
964#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
965impl ::core::cmp::PartialEq for DFS_INFO_3_32 {
966 fn eq(&self, other: &Self) -> bool {
967 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
968 }
969}
970#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
971impl ::core::cmp::Eq for DFS_INFO_3_32 {}
972#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
973impl ::core::default::Default for DFS_INFO_3_32 {
974 fn default() -> Self {
975 unsafe { ::core::mem::zeroed() }
976 }
977}
978#[repr(C)]
979#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
980pub struct DFS_INFO_4 {
981 pub EntryPath: ::windows::core::PWSTR,
982 pub Comment: ::windows::core::PWSTR,
983 pub State: u32,
984 pub Timeout: u32,
985 pub Guid: ::windows::core::GUID,
986 pub NumberOfStorages: u32,
987 pub Storage: *mut DFS_STORAGE_INFO,
988}
989impl ::core::marker::Copy for DFS_INFO_4 {}
990impl ::core::clone::Clone for DFS_INFO_4 {
991 fn clone(&self) -> Self {
992 *self
993 }
994}
995impl ::core::fmt::Debug for DFS_INFO_4 {
996 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
997 f.debug_struct("DFS_INFO_4").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
998 }
999}
1000impl ::windows::core::TypeKind for DFS_INFO_4 {
1001 type TypeKind = ::windows::core::CopyType;
1002}
1003impl ::core::cmp::PartialEq for DFS_INFO_4 {
1004 fn eq(&self, other: &Self) -> bool {
1005 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
1006 }
1007}
1008impl ::core::cmp::Eq for DFS_INFO_4 {}
1009impl ::core::default::Default for DFS_INFO_4 {
1010 fn default() -> Self {
1011 unsafe { ::core::mem::zeroed() }
1012 }
1013}
1014#[repr(C)]
1015#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1016#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1017pub struct DFS_INFO_4_32 {
1018 pub EntryPath: u32,
1019 pub Comment: u32,
1020 pub State: u32,
1021 pub Timeout: u32,
1022 pub Guid: ::windows::core::GUID,
1023 pub NumberOfStorages: u32,
1024 pub Storage: u32,
1025}
1026#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1027impl ::core::marker::Copy for DFS_INFO_4_32 {}
1028#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1029impl ::core::clone::Clone for DFS_INFO_4_32 {
1030 fn clone(&self) -> Self {
1031 *self
1032 }
1033}
1034#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1035impl ::core::fmt::Debug for DFS_INFO_4_32 {
1036 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1037 f.debug_struct("DFS_INFO_4_32").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
1038 }
1039}
1040#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1041impl ::windows::core::TypeKind for DFS_INFO_4_32 {
1042 type TypeKind = ::windows::core::CopyType;
1043}
1044#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1045impl ::core::cmp::PartialEq for DFS_INFO_4_32 {
1046 fn eq(&self, other: &Self) -> bool {
1047 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
1048 }
1049}
1050#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1051impl ::core::cmp::Eq for DFS_INFO_4_32 {}
1052#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1053impl ::core::default::Default for DFS_INFO_4_32 {
1054 fn default() -> Self {
1055 unsafe { ::core::mem::zeroed() }
1056 }
1057}
1058#[repr(C)]
1059#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1060pub struct DFS_INFO_5 {
1061 pub EntryPath: ::windows::core::PWSTR,
1062 pub Comment: ::windows::core::PWSTR,
1063 pub State: u32,
1064 pub Timeout: u32,
1065 pub Guid: ::windows::core::GUID,
1066 pub PropertyFlags: u32,
1067 pub MetadataSize: u32,
1068 pub NumberOfStorages: u32,
1069}
1070impl ::core::marker::Copy for DFS_INFO_5 {}
1071impl ::core::clone::Clone for DFS_INFO_5 {
1072 fn clone(&self) -> Self {
1073 *self
1074 }
1075}
1076impl ::core::fmt::Debug for DFS_INFO_5 {
1077 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1078 f.debug_struct("DFS_INFO_5").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("PropertyFlags", &self.PropertyFlags).field("MetadataSize", &self.MetadataSize).field("NumberOfStorages", &self.NumberOfStorages).finish()
1079 }
1080}
1081impl ::windows::core::TypeKind for DFS_INFO_5 {
1082 type TypeKind = ::windows::core::CopyType;
1083}
1084impl ::core::cmp::PartialEq for DFS_INFO_5 {
1085 fn eq(&self, other: &Self) -> bool {
1086 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.PropertyFlags == other.PropertyFlags && self.MetadataSize == other.MetadataSize && self.NumberOfStorages == other.NumberOfStorages
1087 }
1088}
1089impl ::core::cmp::Eq for DFS_INFO_5 {}
1090impl ::core::default::Default for DFS_INFO_5 {
1091 fn default() -> Self {
1092 unsafe { ::core::mem::zeroed() }
1093 }
1094}
1095#[repr(C)]
1096#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1097pub struct DFS_INFO_50 {
1098 pub NamespaceMajorVersion: u32,
1099 pub NamespaceMinorVersion: u32,
1100 pub NamespaceCapabilities: u64,
1101}
1102impl ::core::marker::Copy for DFS_INFO_50 {}
1103impl ::core::clone::Clone for DFS_INFO_50 {
1104 fn clone(&self) -> Self {
1105 *self
1106 }
1107}
1108impl ::core::fmt::Debug for DFS_INFO_50 {
1109 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1110 f.debug_struct("DFS_INFO_50").field("NamespaceMajorVersion", &self.NamespaceMajorVersion).field("NamespaceMinorVersion", &self.NamespaceMinorVersion).field("NamespaceCapabilities", &self.NamespaceCapabilities).finish()
1111 }
1112}
1113impl ::windows::core::TypeKind for DFS_INFO_50 {
1114 type TypeKind = ::windows::core::CopyType;
1115}
1116impl ::core::cmp::PartialEq for DFS_INFO_50 {
1117 fn eq(&self, other: &Self) -> bool {
1118 self.NamespaceMajorVersion == other.NamespaceMajorVersion && self.NamespaceMinorVersion == other.NamespaceMinorVersion && self.NamespaceCapabilities == other.NamespaceCapabilities
1119 }
1120}
1121impl ::core::cmp::Eq for DFS_INFO_50 {}
1122impl ::core::default::Default for DFS_INFO_50 {
1123 fn default() -> Self {
1124 unsafe { ::core::mem::zeroed() }
1125 }
1126}
1127#[repr(C)]
1128#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1129pub struct DFS_INFO_6 {
1130 pub EntryPath: ::windows::core::PWSTR,
1131 pub Comment: ::windows::core::PWSTR,
1132 pub State: u32,
1133 pub Timeout: u32,
1134 pub Guid: ::windows::core::GUID,
1135 pub PropertyFlags: u32,
1136 pub MetadataSize: u32,
1137 pub NumberOfStorages: u32,
1138 pub Storage: *mut DFS_STORAGE_INFO_1,
1139}
1140impl ::core::marker::Copy for DFS_INFO_6 {}
1141impl ::core::clone::Clone for DFS_INFO_6 {
1142 fn clone(&self) -> Self {
1143 *self
1144 }
1145}
1146impl ::core::fmt::Debug for DFS_INFO_6 {
1147 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1148 f.debug_struct("DFS_INFO_6").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("PropertyFlags", &self.PropertyFlags).field("MetadataSize", &self.MetadataSize).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
1149 }
1150}
1151impl ::windows::core::TypeKind for DFS_INFO_6 {
1152 type TypeKind = ::windows::core::CopyType;
1153}
1154impl ::core::cmp::PartialEq for DFS_INFO_6 {
1155 fn eq(&self, other: &Self) -> bool {
1156 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.PropertyFlags == other.PropertyFlags && self.MetadataSize == other.MetadataSize && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
1157 }
1158}
1159impl ::core::cmp::Eq for DFS_INFO_6 {}
1160impl ::core::default::Default for DFS_INFO_6 {
1161 fn default() -> Self {
1162 unsafe { ::core::mem::zeroed() }
1163 }
1164}
1165#[repr(C)]
1166#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1167pub struct DFS_INFO_7 {
1168 pub GenerationGuid: ::windows::core::GUID,
1169}
1170impl ::core::marker::Copy for DFS_INFO_7 {}
1171impl ::core::clone::Clone for DFS_INFO_7 {
1172 fn clone(&self) -> Self {
1173 *self
1174 }
1175}
1176impl ::core::fmt::Debug for DFS_INFO_7 {
1177 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1178 f.debug_struct("DFS_INFO_7").field("GenerationGuid", &self.GenerationGuid).finish()
1179 }
1180}
1181impl ::windows::core::TypeKind for DFS_INFO_7 {
1182 type TypeKind = ::windows::core::CopyType;
1183}
1184impl ::core::cmp::PartialEq for DFS_INFO_7 {
1185 fn eq(&self, other: &Self) -> bool {
1186 self.GenerationGuid == other.GenerationGuid
1187 }
1188}
1189impl ::core::cmp::Eq for DFS_INFO_7 {}
1190impl ::core::default::Default for DFS_INFO_7 {
1191 fn default() -> Self {
1192 unsafe { ::core::mem::zeroed() }
1193 }
1194}
1195#[repr(C)]
1196#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
1197#[cfg(feature = "Win32_Security")]
1198pub struct DFS_INFO_8 {
1199 pub EntryPath: ::windows::core::PWSTR,
1200 pub Comment: ::windows::core::PWSTR,
1201 pub State: u32,
1202 pub Timeout: u32,
1203 pub Guid: ::windows::core::GUID,
1204 pub PropertyFlags: u32,
1205 pub MetadataSize: u32,
1206 pub SdLengthReserved: u32,
1207 pub pSecurityDescriptor: super::super::Security::PSECURITY_DESCRIPTOR,
1208 pub NumberOfStorages: u32,
1209}
1210#[cfg(feature = "Win32_Security")]
1211impl ::core::marker::Copy for DFS_INFO_8 {}
1212#[cfg(feature = "Win32_Security")]
1213impl ::core::clone::Clone for DFS_INFO_8 {
1214 fn clone(&self) -> Self {
1215 *self
1216 }
1217}
1218#[cfg(feature = "Win32_Security")]
1219impl ::core::fmt::Debug for DFS_INFO_8 {
1220 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1221 f.debug_struct("DFS_INFO_8").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("PropertyFlags", &self.PropertyFlags).field("MetadataSize", &self.MetadataSize).field("SdLengthReserved", &self.SdLengthReserved).field("pSecurityDescriptor", &self.pSecurityDescriptor).field("NumberOfStorages", &self.NumberOfStorages).finish()
1222 }
1223}
1224#[cfg(feature = "Win32_Security")]
1225impl ::windows::core::TypeKind for DFS_INFO_8 {
1226 type TypeKind = ::windows::core::CopyType;
1227}
1228#[cfg(feature = "Win32_Security")]
1229impl ::core::cmp::PartialEq for DFS_INFO_8 {
1230 fn eq(&self, other: &Self) -> bool {
1231 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.PropertyFlags == other.PropertyFlags && self.MetadataSize == other.MetadataSize && self.SdLengthReserved == other.SdLengthReserved && self.pSecurityDescriptor == other.pSecurityDescriptor && self.NumberOfStorages == other.NumberOfStorages
1232 }
1233}
1234#[cfg(feature = "Win32_Security")]
1235impl ::core::cmp::Eq for DFS_INFO_8 {}
1236#[cfg(feature = "Win32_Security")]
1237impl ::core::default::Default for DFS_INFO_8 {
1238 fn default() -> Self {
1239 unsafe { ::core::mem::zeroed() }
1240 }
1241}
1242#[repr(C)]
1243#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`, `\"Win32_Security\"`*"]
1244#[cfg(feature = "Win32_Security")]
1245pub struct DFS_INFO_9 {
1246 pub EntryPath: ::windows::core::PWSTR,
1247 pub Comment: ::windows::core::PWSTR,
1248 pub State: u32,
1249 pub Timeout: u32,
1250 pub Guid: ::windows::core::GUID,
1251 pub PropertyFlags: u32,
1252 pub MetadataSize: u32,
1253 pub SdLengthReserved: u32,
1254 pub pSecurityDescriptor: super::super::Security::PSECURITY_DESCRIPTOR,
1255 pub NumberOfStorages: u32,
1256 pub Storage: *mut DFS_STORAGE_INFO_1,
1257}
1258#[cfg(feature = "Win32_Security")]
1259impl ::core::marker::Copy for DFS_INFO_9 {}
1260#[cfg(feature = "Win32_Security")]
1261impl ::core::clone::Clone for DFS_INFO_9 {
1262 fn clone(&self) -> Self {
1263 *self
1264 }
1265}
1266#[cfg(feature = "Win32_Security")]
1267impl ::core::fmt::Debug for DFS_INFO_9 {
1268 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1269 f.debug_struct("DFS_INFO_9").field("EntryPath", &self.EntryPath).field("Comment", &self.Comment).field("State", &self.State).field("Timeout", &self.Timeout).field("Guid", &self.Guid).field("PropertyFlags", &self.PropertyFlags).field("MetadataSize", &self.MetadataSize).field("SdLengthReserved", &self.SdLengthReserved).field("pSecurityDescriptor", &self.pSecurityDescriptor).field("NumberOfStorages", &self.NumberOfStorages).field("Storage", &self.Storage).finish()
1270 }
1271}
1272#[cfg(feature = "Win32_Security")]
1273impl ::windows::core::TypeKind for DFS_INFO_9 {
1274 type TypeKind = ::windows::core::CopyType;
1275}
1276#[cfg(feature = "Win32_Security")]
1277impl ::core::cmp::PartialEq for DFS_INFO_9 {
1278 fn eq(&self, other: &Self) -> bool {
1279 self.EntryPath == other.EntryPath && self.Comment == other.Comment && self.State == other.State && self.Timeout == other.Timeout && self.Guid == other.Guid && self.PropertyFlags == other.PropertyFlags && self.MetadataSize == other.MetadataSize && self.SdLengthReserved == other.SdLengthReserved && self.pSecurityDescriptor == other.pSecurityDescriptor && self.NumberOfStorages == other.NumberOfStorages && self.Storage == other.Storage
1280 }
1281}
1282#[cfg(feature = "Win32_Security")]
1283impl ::core::cmp::Eq for DFS_INFO_9 {}
1284#[cfg(feature = "Win32_Security")]
1285impl ::core::default::Default for DFS_INFO_9 {
1286 fn default() -> Self {
1287 unsafe { ::core::mem::zeroed() }
1288 }
1289}
1290#[repr(C)]
1291#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1292pub struct DFS_SITELIST_INFO {
1293 pub cSites: u32,
1294 pub Site: [DFS_SITENAME_INFO; 1],
1295}
1296impl ::core::marker::Copy for DFS_SITELIST_INFO {}
1297impl ::core::clone::Clone for DFS_SITELIST_INFO {
1298 fn clone(&self) -> Self {
1299 *self
1300 }
1301}
1302impl ::core::fmt::Debug for DFS_SITELIST_INFO {
1303 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1304 f.debug_struct("DFS_SITELIST_INFO").field("cSites", &self.cSites).field("Site", &self.Site).finish()
1305 }
1306}
1307impl ::windows::core::TypeKind for DFS_SITELIST_INFO {
1308 type TypeKind = ::windows::core::CopyType;
1309}
1310impl ::core::cmp::PartialEq for DFS_SITELIST_INFO {
1311 fn eq(&self, other: &Self) -> bool {
1312 self.cSites == other.cSites && self.Site == other.Site
1313 }
1314}
1315impl ::core::cmp::Eq for DFS_SITELIST_INFO {}
1316impl ::core::default::Default for DFS_SITELIST_INFO {
1317 fn default() -> Self {
1318 unsafe { ::core::mem::zeroed() }
1319 }
1320}
1321#[repr(C)]
1322#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1323pub struct DFS_SITENAME_INFO {
1324 pub SiteFlags: u32,
1325 pub SiteName: ::windows::core::PWSTR,
1326}
1327impl ::core::marker::Copy for DFS_SITENAME_INFO {}
1328impl ::core::clone::Clone for DFS_SITENAME_INFO {
1329 fn clone(&self) -> Self {
1330 *self
1331 }
1332}
1333impl ::core::fmt::Debug for DFS_SITENAME_INFO {
1334 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1335 f.debug_struct("DFS_SITENAME_INFO").field("SiteFlags", &self.SiteFlags).field("SiteName", &self.SiteName).finish()
1336 }
1337}
1338impl ::windows::core::TypeKind for DFS_SITENAME_INFO {
1339 type TypeKind = ::windows::core::CopyType;
1340}
1341impl ::core::cmp::PartialEq for DFS_SITENAME_INFO {
1342 fn eq(&self, other: &Self) -> bool {
1343 self.SiteFlags == other.SiteFlags && self.SiteName == other.SiteName
1344 }
1345}
1346impl ::core::cmp::Eq for DFS_SITENAME_INFO {}
1347impl ::core::default::Default for DFS_SITENAME_INFO {
1348 fn default() -> Self {
1349 unsafe { ::core::mem::zeroed() }
1350 }
1351}
1352#[repr(C)]
1353#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1354pub struct DFS_STORAGE_INFO {
1355 pub State: u32,
1356 pub ServerName: ::windows::core::PWSTR,
1357 pub ShareName: ::windows::core::PWSTR,
1358}
1359impl ::core::marker::Copy for DFS_STORAGE_INFO {}
1360impl ::core::clone::Clone for DFS_STORAGE_INFO {
1361 fn clone(&self) -> Self {
1362 *self
1363 }
1364}
1365impl ::core::fmt::Debug for DFS_STORAGE_INFO {
1366 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1367 f.debug_struct("DFS_STORAGE_INFO").field("State", &self.State).field("ServerName", &self.ServerName).field("ShareName", &self.ShareName).finish()
1368 }
1369}
1370impl ::windows::core::TypeKind for DFS_STORAGE_INFO {
1371 type TypeKind = ::windows::core::CopyType;
1372}
1373impl ::core::cmp::PartialEq for DFS_STORAGE_INFO {
1374 fn eq(&self, other: &Self) -> bool {
1375 self.State == other.State && self.ServerName == other.ServerName && self.ShareName == other.ShareName
1376 }
1377}
1378impl ::core::cmp::Eq for DFS_STORAGE_INFO {}
1379impl ::core::default::Default for DFS_STORAGE_INFO {
1380 fn default() -> Self {
1381 unsafe { ::core::mem::zeroed() }
1382 }
1383}
1384#[repr(C)]
1385#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1386#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1387pub struct DFS_STORAGE_INFO_0_32 {
1388 pub State: u32,
1389 pub ServerName: u32,
1390 pub ShareName: u32,
1391}
1392#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1393impl ::core::marker::Copy for DFS_STORAGE_INFO_0_32 {}
1394#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1395impl ::core::clone::Clone for DFS_STORAGE_INFO_0_32 {
1396 fn clone(&self) -> Self {
1397 *self
1398 }
1399}
1400#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1401impl ::core::fmt::Debug for DFS_STORAGE_INFO_0_32 {
1402 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1403 f.debug_struct("DFS_STORAGE_INFO_0_32").field("State", &self.State).field("ServerName", &self.ServerName).field("ShareName", &self.ShareName).finish()
1404 }
1405}
1406#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1407impl ::windows::core::TypeKind for DFS_STORAGE_INFO_0_32 {
1408 type TypeKind = ::windows::core::CopyType;
1409}
1410#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1411impl ::core::cmp::PartialEq for DFS_STORAGE_INFO_0_32 {
1412 fn eq(&self, other: &Self) -> bool {
1413 self.State == other.State && self.ServerName == other.ServerName && self.ShareName == other.ShareName
1414 }
1415}
1416#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1417impl ::core::cmp::Eq for DFS_STORAGE_INFO_0_32 {}
1418#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1419impl ::core::default::Default for DFS_STORAGE_INFO_0_32 {
1420 fn default() -> Self {
1421 unsafe { ::core::mem::zeroed() }
1422 }
1423}
1424#[repr(C)]
1425#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1426pub struct DFS_STORAGE_INFO_1 {
1427 pub State: u32,
1428 pub ServerName: ::windows::core::PWSTR,
1429 pub ShareName: ::windows::core::PWSTR,
1430 pub TargetPriority: DFS_TARGET_PRIORITY,
1431}
1432impl ::core::marker::Copy for DFS_STORAGE_INFO_1 {}
1433impl ::core::clone::Clone for DFS_STORAGE_INFO_1 {
1434 fn clone(&self) -> Self {
1435 *self
1436 }
1437}
1438impl ::core::fmt::Debug for DFS_STORAGE_INFO_1 {
1439 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1440 f.debug_struct("DFS_STORAGE_INFO_1").field("State", &self.State).field("ServerName", &self.ServerName).field("ShareName", &self.ShareName).field("TargetPriority", &self.TargetPriority).finish()
1441 }
1442}
1443impl ::windows::core::TypeKind for DFS_STORAGE_INFO_1 {
1444 type TypeKind = ::windows::core::CopyType;
1445}
1446impl ::core::cmp::PartialEq for DFS_STORAGE_INFO_1 {
1447 fn eq(&self, other: &Self) -> bool {
1448 self.State == other.State && self.ServerName == other.ServerName && self.ShareName == other.ShareName && self.TargetPriority == other.TargetPriority
1449 }
1450}
1451impl ::core::cmp::Eq for DFS_STORAGE_INFO_1 {}
1452impl ::core::default::Default for DFS_STORAGE_INFO_1 {
1453 fn default() -> Self {
1454 unsafe { ::core::mem::zeroed() }
1455 }
1456}
1457#[repr(C)]
1458#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1459pub struct DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1460 pub DomainDfsMajorVersion: u32,
1461 pub DomainDfsMinorVersion: u32,
1462 pub DomainDfsCapabilities: u64,
1463 pub StandaloneDfsMajorVersion: u32,
1464 pub StandaloneDfsMinorVersion: u32,
1465 pub StandaloneDfsCapabilities: u64,
1466}
1467impl ::core::marker::Copy for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {}
1468impl ::core::clone::Clone for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1469 fn clone(&self) -> Self {
1470 *self
1471 }
1472}
1473impl ::core::fmt::Debug for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1474 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1475 f.debug_struct("DFS_SUPPORTED_NAMESPACE_VERSION_INFO").field("DomainDfsMajorVersion", &self.DomainDfsMajorVersion).field("DomainDfsMinorVersion", &self.DomainDfsMinorVersion).field("DomainDfsCapabilities", &self.DomainDfsCapabilities).field("StandaloneDfsMajorVersion", &self.StandaloneDfsMajorVersion).field("StandaloneDfsMinorVersion", &self.StandaloneDfsMinorVersion).field("StandaloneDfsCapabilities", &self.StandaloneDfsCapabilities).finish()
1476 }
1477}
1478impl ::windows::core::TypeKind for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1479 type TypeKind = ::windows::core::CopyType;
1480}
1481impl ::core::cmp::PartialEq for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1482 fn eq(&self, other: &Self) -> bool {
1483 self.DomainDfsMajorVersion == other.DomainDfsMajorVersion && self.DomainDfsMinorVersion == other.DomainDfsMinorVersion && self.DomainDfsCapabilities == other.DomainDfsCapabilities && self.StandaloneDfsMajorVersion == other.StandaloneDfsMajorVersion && self.StandaloneDfsMinorVersion == other.StandaloneDfsMinorVersion && self.StandaloneDfsCapabilities == other.StandaloneDfsCapabilities
1484 }
1485}
1486impl ::core::cmp::Eq for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {}
1487impl ::core::default::Default for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1488 fn default() -> Self {
1489 unsafe { ::core::mem::zeroed() }
1490 }
1491}
1492#[repr(C)]
1493#[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
1494pub struct DFS_TARGET_PRIORITY {
1495 pub TargetPriorityClass: DFS_TARGET_PRIORITY_CLASS,
1496 pub TargetPriorityRank: u16,
1497 pub Reserved: u16,
1498}
1499impl ::core::marker::Copy for DFS_TARGET_PRIORITY {}
1500impl ::core::clone::Clone for DFS_TARGET_PRIORITY {
1501 fn clone(&self) -> Self {
1502 *self
1503 }
1504}
1505impl ::core::fmt::Debug for DFS_TARGET_PRIORITY {
1506 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1507 f.debug_struct("DFS_TARGET_PRIORITY").field("TargetPriorityClass", &self.TargetPriorityClass).field("TargetPriorityRank", &self.TargetPriorityRank).field("Reserved", &self.Reserved).finish()
1508 }
1509}
1510impl ::windows::core::TypeKind for DFS_TARGET_PRIORITY {
1511 type TypeKind = ::windows::core::CopyType;
1512}
1513impl ::core::cmp::PartialEq for DFS_TARGET_PRIORITY {
1514 fn eq(&self, other: &Self) -> bool {
1515 self.TargetPriorityClass == other.TargetPriorityClass && self.TargetPriorityRank == other.TargetPriorityRank && self.Reserved == other.Reserved
1516 }
1517}
1518impl ::core::cmp::Eq for DFS_TARGET_PRIORITY {}
1519impl ::core::default::Default for DFS_TARGET_PRIORITY {
1520 fn default() -> Self {
1521 unsafe { ::core::mem::zeroed() }
1522 }
1523}
1524#[cfg(feature = "implement")]
1525::core::include!("impl.rs");
backport for Debian buster