vendor/windows/src/Windows/Win32/Storage/DistributedFileSystem/mod.rs

   1 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
   2 #[inline]
   3 pub unsafe fn NetDfsAdd<P0, P1, P2, P3>(dfsentrypath: P0, servername: P1, sharename: P2, comment: P3, flags: u32) -> u32
   4 where
   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]
  15 pub unsafe fn NetDfsAddFtRoot<P0, P1, P2, P3>(servername: P0, rootshare: P1, ftdfsname: P2, comment: P3, flags: u32) -> u32
  16 where
  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]
  27 pub unsafe fn NetDfsAddRootTarget<P0, P1, P2>(pdfspath: P0, ptargetpath: P1, majorversion: u32, pcomment: P2, flags: u32) -> u32
  28 where
  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]
  38 pub unsafe fn NetDfsAddStdRoot<P0, P1, P2>(servername: P0, rootshare: P1, comment: P2, flags: u32) -> u32
  39 where
  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]
  49 pub unsafe fn NetDfsEnum<P0>(dfsname: P0, level: u32, prefmaxlen: u32, buffer: *mut *mut u8, entriesread: *mut u32, resumehandle: *mut u32) -> u32
  50 where
  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]
  58 pub unsafe fn NetDfsGetClientInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *mut *mut u8) -> u32
  59 where
  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]
  70 pub unsafe fn NetDfsGetFtContainerSecurity<P0>(domainname: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
  71 where
  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]
  79 pub unsafe fn NetDfsGetInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *mut *mut u8) -> u32
  80 where
  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]
  91 pub unsafe fn NetDfsGetSecurity<P0>(dfsentrypath: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
  92 where
  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]
 101 pub unsafe fn NetDfsGetStdContainerSecurity<P0>(machinename: P0, securityinformation: u32, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, lpcbsecuritydescriptor: *mut u32) -> u32
 102 where
 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]
 110 pub unsafe fn NetDfsGetSupportedNamespaceVersion<P0>(origin: DFS_NAMESPACE_VERSION_ORIGIN, pname: P0, ppversioninfo: *mut *mut DFS_SUPPORTED_NAMESPACE_VERSION_INFO) -> u32
 111 where
 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]
 119 pub unsafe fn NetDfsMove<P0, P1>(olddfsentrypath: P0, newdfsentrypath: P1, flags: u32) -> u32
 120 where
 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]
 129 pub unsafe fn NetDfsRemove<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2) -> u32
 130 where
 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]
 140 pub unsafe fn NetDfsRemoveFtRoot<P0, P1, P2>(servername: P0, rootshare: P1, ftdfsname: P2, flags: u32) -> u32
 141 where
 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]
 151 pub unsafe fn NetDfsRemoveFtRootForced<P0, P1, P2, P3>(domainname: P0, servername: P1, rootshare: P2, ftdfsname: P3, flags: u32) -> u32
 152 where
 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]
 163 pub unsafe fn NetDfsRemoveRootTarget<P0, P1>(pdfspath: P0, ptargetpath: P1, flags: u32) -> u32
 164 where
 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]
 173 pub unsafe fn NetDfsRemoveStdRoot<P0, P1>(servername: P0, rootshare: P1, flags: u32) -> u32
 174 where
 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]
 183 pub unsafe fn NetDfsSetClientInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *const u8) -> u32
 184 where
 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]
 195 pub unsafe fn NetDfsSetFtContainerSecurity<P0, P1>(domainname: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
 196 where
 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]
 205 pub unsafe fn NetDfsSetInfo<P0, P1, P2>(dfsentrypath: P0, servername: P1, sharename: P2, level: u32, buffer: *const u8) -> u32
 206 where
 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]
 217 pub unsafe fn NetDfsSetSecurity<P0, P1>(dfsentrypath: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
 218 where
 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]
 228 pub unsafe fn NetDfsSetStdContainerSecurity<P0, P1>(machinename: P0, securityinformation: u32, psecuritydescriptor: P1) -> u32
 229 where
 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\"`*"]
 237 pub const DFS_ADD_VOLUME: u32 = 1u32;
 238 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 239 pub const DFS_FORCE_REMOVE: u32 = 2147483648u32;
 240 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 241 pub const DFS_MOVE_FLAG_REPLACE_IF_EXISTS: u32 = 1u32;
 242 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 243 pub const DFS_PROPERTY_FLAG_ABDE: u32 = 32u32;
 244 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 245 pub const DFS_PROPERTY_FLAG_CLUSTER_ENABLED: u32 = 16u32;
 246 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 247 pub const DFS_PROPERTY_FLAG_INSITE_REFERRALS: u32 = 1u32;
 248 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 249 pub const DFS_PROPERTY_FLAG_ROOT_SCALABILITY: u32 = 2u32;
 250 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 251 pub const DFS_PROPERTY_FLAG_SITE_COSTING: u32 = 4u32;
 252 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 253 pub const DFS_PROPERTY_FLAG_TARGET_FAILBACK: u32 = 8u32;
 254 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 255 pub const DFS_RESTORE_VOLUME: u32 = 2u32;
 256 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 257 pub const DFS_SITE_PRIMARY: u32 = 1u32;
 258 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 259 pub const DFS_STORAGE_FLAVOR_UNUSED2: u32 = 768u32;
 260 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 261 pub const DFS_STORAGE_STATES: u32 = 15u32;
 262 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 263 pub const DFS_STORAGE_STATE_ACTIVE: u32 = 4u32;
 264 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 265 pub const DFS_STORAGE_STATE_OFFLINE: u32 = 1u32;
 266 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 267 pub const DFS_STORAGE_STATE_ONLINE: u32 = 2u32;
 268 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 269 pub const DFS_VOLUME_FLAVORS: u32 = 768u32;
 270 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 271 pub const DFS_VOLUME_FLAVOR_AD_BLOB: u32 = 512u32;
 272 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 273 pub const DFS_VOLUME_FLAVOR_STANDALONE: u32 = 256u32;
 274 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 275 pub const DFS_VOLUME_FLAVOR_UNUSED1: u32 = 0u32;
 276 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 277 pub const DFS_VOLUME_STATES: u32 = 15u32;
 278 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 279 pub const DFS_VOLUME_STATE_FORCE_SYNC: u32 = 64u32;
 280 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 281 pub const DFS_VOLUME_STATE_INCONSISTENT: u32 = 2u32;
 282 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 283 pub const DFS_VOLUME_STATE_OFFLINE: u32 = 3u32;
 284 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 285 pub const DFS_VOLUME_STATE_OK: u32 = 1u32;
 286 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 287 pub const DFS_VOLUME_STATE_ONLINE: u32 = 4u32;
 288 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 289 pub const DFS_VOLUME_STATE_RESYNCHRONIZE: u32 = 16u32;
 290 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 291 pub const DFS_VOLUME_STATE_STANDBY: u32 = 32u32;
 292 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 293 pub const FSCTL_DFS_BASE: u32 = 6u32;
 294 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 295 pub const FSCTL_DFS_GET_PKT_ENTRY_STATE: u32 = 401340u32;
 296 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 297 pub const NET_DFS_SETDC_FLAGS: u32 = 0u32;
 298 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 299 pub const NET_DFS_SETDC_INITPKT: u32 = 2u32;
 300 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 301 pub 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)]
 305 pub struct DFS_NAMESPACE_VERSION_ORIGIN(pub i32);
 306 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 307 pub const DFS_NAMESPACE_VERSION_ORIGIN_COMBINED: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(0i32);
 308 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 309 pub const DFS_NAMESPACE_VERSION_ORIGIN_SERVER: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(1i32);
 310 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 311 pub const DFS_NAMESPACE_VERSION_ORIGIN_DOMAIN: DFS_NAMESPACE_VERSION_ORIGIN = DFS_NAMESPACE_VERSION_ORIGIN(2i32);
 312 impl ::core::marker::Copy for DFS_NAMESPACE_VERSION_ORIGIN {}
 313 impl ::core::clone::Clone for DFS_NAMESPACE_VERSION_ORIGIN {
 314     fn clone(&self) -> Self {
 315         *self
 316     }
 317 }
 318 impl ::core::default::Default for DFS_NAMESPACE_VERSION_ORIGIN {
 319     fn default() -> Self {
 320         Self(0)
 321     }
 322 }
 323 impl ::windows::core::TypeKind for DFS_NAMESPACE_VERSION_ORIGIN {
 324     type TypeKind = ::windows::core::CopyType;
 325 }
 326 impl ::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)]
 334 pub struct DFS_TARGET_PRIORITY_CLASS(pub i32);
 335 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 336 pub const DfsInvalidPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(-1i32);
 337 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 338 pub const DfsSiteCostNormalPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(0i32);
 339 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 340 pub const DfsGlobalHighPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(1i32);
 341 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 342 pub const DfsSiteCostHighPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(2i32);
 343 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 344 pub const DfsSiteCostLowPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(3i32);
 345 #[doc = "*Required features: `\"Win32_Storage_DistributedFileSystem\"`*"]
 346 pub const DfsGlobalLowPriorityClass: DFS_TARGET_PRIORITY_CLASS = DFS_TARGET_PRIORITY_CLASS(4i32);
 347 impl ::core::marker::Copy for DFS_TARGET_PRIORITY_CLASS {}
 348 impl ::core::clone::Clone for DFS_TARGET_PRIORITY_CLASS {
 349     fn clone(&self) -> Self {
 350         *self
 351     }
 352 }
 353 impl ::core::default::Default for DFS_TARGET_PRIORITY_CLASS {
 354     fn default() -> Self {
 355         Self(0)
 356     }
 357 }
 358 impl ::windows::core::TypeKind for DFS_TARGET_PRIORITY_CLASS {
 359     type TypeKind = ::windows::core::CopyType;
 360 }
 361 impl ::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\"`*"]
 368 pub 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 }
 375 impl ::core::marker::Copy for DFS_GET_PKT_ENTRY_STATE_ARG {}
 376 impl ::core::clone::Clone for DFS_GET_PKT_ENTRY_STATE_ARG {
 377     fn clone(&self) -> Self {
 378         *self
 379     }
 380 }
 381 impl ::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 }
 386 impl ::windows::core::TypeKind for DFS_GET_PKT_ENTRY_STATE_ARG {
 387     type TypeKind = ::windows::core::CopyType;
 388 }
 389 impl ::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 }
 394 impl ::core::cmp::Eq for DFS_GET_PKT_ENTRY_STATE_ARG {}
 395 impl ::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\"`*"]
 402 pub struct DFS_INFO_1 {
 403     pub EntryPath: ::windows::core::PWSTR,
 404 }
 405 impl ::core::marker::Copy for DFS_INFO_1 {}
 406 impl ::core::clone::Clone for DFS_INFO_1 {
 407     fn clone(&self) -> Self {
 408         *self
 409     }
 410 }
 411 impl ::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 }
 416 impl ::windows::core::TypeKind for DFS_INFO_1 {
 417     type TypeKind = ::windows::core::CopyType;
 418 }
 419 impl ::core::cmp::PartialEq for DFS_INFO_1 {
 420     fn eq(&self, other: &Self) -> bool {
 421         self.EntryPath == other.EntryPath
 422     }
 423 }
 424 impl ::core::cmp::Eq for DFS_INFO_1 {}
 425 impl ::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\"`*"]
 432 pub struct DFS_INFO_100 {
 433     pub Comment: ::windows::core::PWSTR,
 434 }
 435 impl ::core::marker::Copy for DFS_INFO_100 {}
 436 impl ::core::clone::Clone for DFS_INFO_100 {
 437     fn clone(&self) -> Self {
 438         *self
 439     }
 440 }
 441 impl ::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 }
 446 impl ::windows::core::TypeKind for DFS_INFO_100 {
 447     type TypeKind = ::windows::core::CopyType;
 448 }
 449 impl ::core::cmp::PartialEq for DFS_INFO_100 {
 450     fn eq(&self, other: &Self) -> bool {
 451         self.Comment == other.Comment
 452     }
 453 }
 454 impl ::core::cmp::Eq for DFS_INFO_100 {}
 455 impl ::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\"`*"]
 462 pub struct DFS_INFO_101 {
 463     pub State: u32,
 464 }
 465 impl ::core::marker::Copy for DFS_INFO_101 {}
 466 impl ::core::clone::Clone for DFS_INFO_101 {
 467     fn clone(&self) -> Self {
 468         *self
 469     }
 470 }
 471 impl ::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 }
 476 impl ::windows::core::TypeKind for DFS_INFO_101 {
 477     type TypeKind = ::windows::core::CopyType;
 478 }
 479 impl ::core::cmp::PartialEq for DFS_INFO_101 {
 480     fn eq(&self, other: &Self) -> bool {
 481         self.State == other.State
 482     }
 483 }
 484 impl ::core::cmp::Eq for DFS_INFO_101 {}
 485 impl ::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\"`*"]
 492 pub struct DFS_INFO_102 {
 493     pub Timeout: u32,
 494 }
 495 impl ::core::marker::Copy for DFS_INFO_102 {}
 496 impl ::core::clone::Clone for DFS_INFO_102 {
 497     fn clone(&self) -> Self {
 498         *self
 499     }
 500 }
 501 impl ::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 }
 506 impl ::windows::core::TypeKind for DFS_INFO_102 {
 507     type TypeKind = ::windows::core::CopyType;
 508 }
 509 impl ::core::cmp::PartialEq for DFS_INFO_102 {
 510     fn eq(&self, other: &Self) -> bool {
 511         self.Timeout == other.Timeout
 512     }
 513 }
 514 impl ::core::cmp::Eq for DFS_INFO_102 {}
 515 impl ::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\"`*"]
 522 pub struct DFS_INFO_103 {
 523     pub PropertyFlagMask: u32,
 524     pub PropertyFlags: u32,
 525 }
 526 impl ::core::marker::Copy for DFS_INFO_103 {}
 527 impl ::core::clone::Clone for DFS_INFO_103 {
 528     fn clone(&self) -> Self {
 529         *self
 530     }
 531 }
 532 impl ::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 }
 537 impl ::windows::core::TypeKind for DFS_INFO_103 {
 538     type TypeKind = ::windows::core::CopyType;
 539 }
 540 impl ::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 }
 545 impl ::core::cmp::Eq for DFS_INFO_103 {}
 546 impl ::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\"`*"]
 553 pub struct DFS_INFO_104 {
 554     pub TargetPriority: DFS_TARGET_PRIORITY,
 555 }
 556 impl ::core::marker::Copy for DFS_INFO_104 {}
 557 impl ::core::clone::Clone for DFS_INFO_104 {
 558     fn clone(&self) -> Self {
 559         *self
 560     }
 561 }
 562 impl ::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 }
 567 impl ::windows::core::TypeKind for DFS_INFO_104 {
 568     type TypeKind = ::windows::core::CopyType;
 569 }
 570 impl ::core::cmp::PartialEq for DFS_INFO_104 {
 571     fn eq(&self, other: &Self) -> bool {
 572         self.TargetPriority == other.TargetPriority
 573     }
 574 }
 575 impl ::core::cmp::Eq for DFS_INFO_104 {}
 576 impl ::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\"`*"]
 583 pub 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 }
 590 impl ::core::marker::Copy for DFS_INFO_105 {}
 591 impl ::core::clone::Clone for DFS_INFO_105 {
 592     fn clone(&self) -> Self {
 593         *self
 594     }
 595 }
 596 impl ::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 }
 601 impl ::windows::core::TypeKind for DFS_INFO_105 {
 602     type TypeKind = ::windows::core::CopyType;
 603 }
 604 impl ::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 }
 609 impl ::core::cmp::Eq for DFS_INFO_105 {}
 610 impl ::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\"`*"]
 617 pub struct DFS_INFO_106 {
 618     pub State: u32,
 619     pub TargetPriority: DFS_TARGET_PRIORITY,
 620 }
 621 impl ::core::marker::Copy for DFS_INFO_106 {}
 622 impl ::core::clone::Clone for DFS_INFO_106 {
 623     fn clone(&self) -> Self {
 624         *self
 625     }
 626 }
 627 impl ::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 }
 632 impl ::windows::core::TypeKind for DFS_INFO_106 {
 633     type TypeKind = ::windows::core::CopyType;
 634 }
 635 impl ::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 }
 640 impl ::core::cmp::Eq for DFS_INFO_106 {}
 641 impl ::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")]
 649 pub 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")]
 659 impl ::core::marker::Copy for DFS_INFO_107 {}
 660 #[cfg(feature = "Win32_Security")]
 661 impl ::core::clone::Clone for DFS_INFO_107 {
 662     fn clone(&self) -> Self {
 663         *self
 664     }
 665 }
 666 #[cfg(feature = "Win32_Security")]
 667 impl ::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")]
 673 impl ::windows::core::TypeKind for DFS_INFO_107 {
 674     type TypeKind = ::windows::core::CopyType;
 675 }
 676 #[cfg(feature = "Win32_Security")]
 677 impl ::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")]
 683 impl ::core::cmp::Eq for DFS_INFO_107 {}
 684 #[cfg(feature = "Win32_Security")]
 685 impl ::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")]
 693 pub struct DFS_INFO_150 {
 694     pub SdLengthReserved: u32,
 695     pub pSecurityDescriptor: super::super::Security::PSECURITY_DESCRIPTOR,
 696 }
 697 #[cfg(feature = "Win32_Security")]
 698 impl ::core::marker::Copy for DFS_INFO_150 {}
 699 #[cfg(feature = "Win32_Security")]
 700 impl ::core::clone::Clone for DFS_INFO_150 {
 701     fn clone(&self) -> Self {
 702         *self
 703     }
 704 }
 705 #[cfg(feature = "Win32_Security")]
 706 impl ::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")]
 712 impl ::windows::core::TypeKind for DFS_INFO_150 {
 713     type TypeKind = ::windows::core::CopyType;
 714 }
 715 #[cfg(feature = "Win32_Security")]
 716 impl ::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")]
 722 impl ::core::cmp::Eq for DFS_INFO_150 {}
 723 #[cfg(feature = "Win32_Security")]
 724 impl ::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"))]
 732 pub struct DFS_INFO_1_32 {
 733     pub EntryPath: u32,
 734 }
 735 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 736 impl ::core::marker::Copy for DFS_INFO_1_32 {}
 737 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 738 impl ::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"))]
 744 impl ::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"))]
 750 impl ::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"))]
 754 impl ::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"))]
 760 impl ::core::cmp::Eq for DFS_INFO_1_32 {}
 761 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 762 impl ::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\"`*"]
 769 pub 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 }
 775 impl ::core::marker::Copy for DFS_INFO_2 {}
 776 impl ::core::clone::Clone for DFS_INFO_2 {
 777     fn clone(&self) -> Self {
 778         *self
 779     }
 780 }
 781 impl ::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 }
 786 impl ::windows::core::TypeKind for DFS_INFO_2 {
 787     type TypeKind = ::windows::core::CopyType;
 788 }
 789 impl ::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 }
 794 impl ::core::cmp::Eq for DFS_INFO_2 {}
 795 impl ::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\"`*"]
 802 pub struct DFS_INFO_200 {
 803     pub FtDfsName: ::windows::core::PWSTR,
 804 }
 805 impl ::core::marker::Copy for DFS_INFO_200 {}
 806 impl ::core::clone::Clone for DFS_INFO_200 {
 807     fn clone(&self) -> Self {
 808         *self
 809     }
 810 }
 811 impl ::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 }
 816 impl ::windows::core::TypeKind for DFS_INFO_200 {
 817     type TypeKind = ::windows::core::CopyType;
 818 }
 819 impl ::core::cmp::PartialEq for DFS_INFO_200 {
 820     fn eq(&self, other: &Self) -> bool {
 821         self.FtDfsName == other.FtDfsName
 822     }
 823 }
 824 impl ::core::cmp::Eq for DFS_INFO_200 {}
 825 impl ::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"))]
 833 pub 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"))]
 840 impl ::core::marker::Copy for DFS_INFO_2_32 {}
 841 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 842 impl ::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"))]
 848 impl ::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"))]
 854 impl ::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"))]
 858 impl ::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"))]
 864 impl ::core::cmp::Eq for DFS_INFO_2_32 {}
 865 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 866 impl ::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\"`*"]
 873 pub 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 }
 880 impl ::core::marker::Copy for DFS_INFO_3 {}
 881 impl ::core::clone::Clone for DFS_INFO_3 {
 882     fn clone(&self) -> Self {
 883         *self
 884     }
 885 }
 886 impl ::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 }
 891 impl ::windows::core::TypeKind for DFS_INFO_3 {
 892     type TypeKind = ::windows::core::CopyType;
 893 }
 894 impl ::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 }
 899 impl ::core::cmp::Eq for DFS_INFO_3 {}
 900 impl ::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\"`*"]
 907 pub struct DFS_INFO_300 {
 908     pub Flags: u32,
 909     pub DfsName: ::windows::core::PWSTR,
 910 }
 911 impl ::core::marker::Copy for DFS_INFO_300 {}
 912 impl ::core::clone::Clone for DFS_INFO_300 {
 913     fn clone(&self) -> Self {
 914         *self
 915     }
 916 }
 917 impl ::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 }
 922 impl ::windows::core::TypeKind for DFS_INFO_300 {
 923     type TypeKind = ::windows::core::CopyType;
 924 }
 925 impl ::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 }
 930 impl ::core::cmp::Eq for DFS_INFO_300 {}
 931 impl ::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"))]
 939 pub 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"))]
 947 impl ::core::marker::Copy for DFS_INFO_3_32 {}
 948 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 949 impl ::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"))]
 955 impl ::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"))]
 961 impl ::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"))]
 965 impl ::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"))]
 971 impl ::core::cmp::Eq for DFS_INFO_3_32 {}
 972 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
 973 impl ::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\"`*"]
 980 pub 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 }
 989 impl ::core::marker::Copy for DFS_INFO_4 {}
 990 impl ::core::clone::Clone for DFS_INFO_4 {
 991     fn clone(&self) -> Self {
 992         *self
 993     }
 994 }
 995 impl ::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 }
1000 impl ::windows::core::TypeKind for DFS_INFO_4 {
1001     type TypeKind = ::windows::core::CopyType;
1002 }
1003 impl ::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 }
1008 impl ::core::cmp::Eq for DFS_INFO_4 {}
1009 impl ::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"))]
1017 pub 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"))]
1027 impl ::core::marker::Copy for DFS_INFO_4_32 {}
1028 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1029 impl ::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"))]
1035 impl ::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"))]
1041 impl ::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"))]
1045 impl ::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"))]
1051 impl ::core::cmp::Eq for DFS_INFO_4_32 {}
1052 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1053 impl ::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\"`*"]
1060 pub 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 }
1070 impl ::core::marker::Copy for DFS_INFO_5 {}
1071 impl ::core::clone::Clone for DFS_INFO_5 {
1072     fn clone(&self) -> Self {
1073         *self
1074     }
1075 }
1076 impl ::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 }
1081 impl ::windows::core::TypeKind for DFS_INFO_5 {
1082     type TypeKind = ::windows::core::CopyType;
1083 }
1084 impl ::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 }
1089 impl ::core::cmp::Eq for DFS_INFO_5 {}
1090 impl ::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\"`*"]
1097 pub struct DFS_INFO_50 {
1098     pub NamespaceMajorVersion: u32,
1099     pub NamespaceMinorVersion: u32,
1100     pub NamespaceCapabilities: u64,
1101 }
1102 impl ::core::marker::Copy for DFS_INFO_50 {}
1103 impl ::core::clone::Clone for DFS_INFO_50 {
1104     fn clone(&self) -> Self {
1105         *self
1106     }
1107 }
1108 impl ::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 }
1113 impl ::windows::core::TypeKind for DFS_INFO_50 {
1114     type TypeKind = ::windows::core::CopyType;
1115 }
1116 impl ::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 }
1121 impl ::core::cmp::Eq for DFS_INFO_50 {}
1122 impl ::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\"`*"]
1129 pub 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 }
1140 impl ::core::marker::Copy for DFS_INFO_6 {}
1141 impl ::core::clone::Clone for DFS_INFO_6 {
1142     fn clone(&self) -> Self {
1143         *self
1144     }
1145 }
1146 impl ::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 }
1151 impl ::windows::core::TypeKind for DFS_INFO_6 {
1152     type TypeKind = ::windows::core::CopyType;
1153 }
1154 impl ::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 }
1159 impl ::core::cmp::Eq for DFS_INFO_6 {}
1160 impl ::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\"`*"]
1167 pub struct DFS_INFO_7 {
1168     pub GenerationGuid: ::windows::core::GUID,
1169 }
1170 impl ::core::marker::Copy for DFS_INFO_7 {}
1171 impl ::core::clone::Clone for DFS_INFO_7 {
1172     fn clone(&self) -> Self {
1173         *self
1174     }
1175 }
1176 impl ::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 }
1181 impl ::windows::core::TypeKind for DFS_INFO_7 {
1182     type TypeKind = ::windows::core::CopyType;
1183 }
1184 impl ::core::cmp::PartialEq for DFS_INFO_7 {
1185     fn eq(&self, other: &Self) -> bool {
1186         self.GenerationGuid == other.GenerationGuid
1187     }
1188 }
1189 impl ::core::cmp::Eq for DFS_INFO_7 {}
1190 impl ::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")]
1198 pub 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")]
1211 impl ::core::marker::Copy for DFS_INFO_8 {}
1212 #[cfg(feature = "Win32_Security")]
1213 impl ::core::clone::Clone for DFS_INFO_8 {
1214     fn clone(&self) -> Self {
1215         *self
1216     }
1217 }
1218 #[cfg(feature = "Win32_Security")]
1219 impl ::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")]
1225 impl ::windows::core::TypeKind for DFS_INFO_8 {
1226     type TypeKind = ::windows::core::CopyType;
1227 }
1228 #[cfg(feature = "Win32_Security")]
1229 impl ::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")]
1235 impl ::core::cmp::Eq for DFS_INFO_8 {}
1236 #[cfg(feature = "Win32_Security")]
1237 impl ::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")]
1245 pub 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")]
1259 impl ::core::marker::Copy for DFS_INFO_9 {}
1260 #[cfg(feature = "Win32_Security")]
1261 impl ::core::clone::Clone for DFS_INFO_9 {
1262     fn clone(&self) -> Self {
1263         *self
1264     }
1265 }
1266 #[cfg(feature = "Win32_Security")]
1267 impl ::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")]
1273 impl ::windows::core::TypeKind for DFS_INFO_9 {
1274     type TypeKind = ::windows::core::CopyType;
1275 }
1276 #[cfg(feature = "Win32_Security")]
1277 impl ::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")]
1283 impl ::core::cmp::Eq for DFS_INFO_9 {}
1284 #[cfg(feature = "Win32_Security")]
1285 impl ::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\"`*"]
1292 pub struct DFS_SITELIST_INFO {
1293     pub cSites: u32,
1294     pub Site: [DFS_SITENAME_INFO; 1],
1295 }
1296 impl ::core::marker::Copy for DFS_SITELIST_INFO {}
1297 impl ::core::clone::Clone for DFS_SITELIST_INFO {
1298     fn clone(&self) -> Self {
1299         *self
1300     }
1301 }
1302 impl ::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 }
1307 impl ::windows::core::TypeKind for DFS_SITELIST_INFO {
1308     type TypeKind = ::windows::core::CopyType;
1309 }
1310 impl ::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 }
1315 impl ::core::cmp::Eq for DFS_SITELIST_INFO {}
1316 impl ::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\"`*"]
1323 pub struct DFS_SITENAME_INFO {
1324     pub SiteFlags: u32,
1325     pub SiteName: ::windows::core::PWSTR,
1326 }
1327 impl ::core::marker::Copy for DFS_SITENAME_INFO {}
1328 impl ::core::clone::Clone for DFS_SITENAME_INFO {
1329     fn clone(&self) -> Self {
1330         *self
1331     }
1332 }
1333 impl ::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 }
1338 impl ::windows::core::TypeKind for DFS_SITENAME_INFO {
1339     type TypeKind = ::windows::core::CopyType;
1340 }
1341 impl ::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 }
1346 impl ::core::cmp::Eq for DFS_SITENAME_INFO {}
1347 impl ::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\"`*"]
1354 pub struct DFS_STORAGE_INFO {
1355     pub State: u32,
1356     pub ServerName: ::windows::core::PWSTR,
1357     pub ShareName: ::windows::core::PWSTR,
1358 }
1359 impl ::core::marker::Copy for DFS_STORAGE_INFO {}
1360 impl ::core::clone::Clone for DFS_STORAGE_INFO {
1361     fn clone(&self) -> Self {
1362         *self
1363     }
1364 }
1365 impl ::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 }
1370 impl ::windows::core::TypeKind for DFS_STORAGE_INFO {
1371     type TypeKind = ::windows::core::CopyType;
1372 }
1373 impl ::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 }
1378 impl ::core::cmp::Eq for DFS_STORAGE_INFO {}
1379 impl ::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"))]
1387 pub 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"))]
1393 impl ::core::marker::Copy for DFS_STORAGE_INFO_0_32 {}
1394 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1395 impl ::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"))]
1401 impl ::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"))]
1407 impl ::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"))]
1411 impl ::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"))]
1417 impl ::core::cmp::Eq for DFS_STORAGE_INFO_0_32 {}
1418 #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
1419 impl ::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\"`*"]
1426 pub 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 }
1432 impl ::core::marker::Copy for DFS_STORAGE_INFO_1 {}
1433 impl ::core::clone::Clone for DFS_STORAGE_INFO_1 {
1434     fn clone(&self) -> Self {
1435         *self
1436     }
1437 }
1438 impl ::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 }
1443 impl ::windows::core::TypeKind for DFS_STORAGE_INFO_1 {
1444     type TypeKind = ::windows::core::CopyType;
1445 }
1446 impl ::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 }
1451 impl ::core::cmp::Eq for DFS_STORAGE_INFO_1 {}
1452 impl ::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\"`*"]
1459 pub 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 }
1467 impl ::core::marker::Copy for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {}
1468 impl ::core::clone::Clone for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1469     fn clone(&self) -> Self {
1470         *self
1471     }
1472 }
1473 impl ::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 }
1478 impl ::windows::core::TypeKind for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {
1479     type TypeKind = ::windows::core::CopyType;
1480 }
1481 impl ::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 }
1486 impl ::core::cmp::Eq for DFS_SUPPORTED_NAMESPACE_VERSION_INFO {}
1487 impl ::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\"`*"]
1494 pub struct DFS_TARGET_PRIORITY {
1495     pub TargetPriorityClass: DFS_TARGET_PRIORITY_CLASS,
1496     pub TargetPriorityRank: u16,
1497     pub Reserved: u16,
1498 }
1499 impl ::core::marker::Copy for DFS_TARGET_PRIORITY {}
1500 impl ::core::clone::Clone for DFS_TARGET_PRIORITY {
1501     fn clone(&self) -> Self {
1502         *self
1503     }
1504 }
1505 impl ::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 }
1510 impl ::windows::core::TypeKind for DFS_TARGET_PRIORITY {
1511     type TypeKind = ::windows::core::CopyType;
1512 }
1513 impl ::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 }
1518 impl ::core::cmp::Eq for DFS_TARGET_PRIORITY {}
1519 impl ::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");