vendor/windows-sys-0.28.0/src/Windows/Win32/System/Ioctl/mod.rs

   1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
   2 #[link(name = "windows")]
   3 extern "system" {}
   4 pub const ASSERT_ALTERNATE: u32 = 9u32;
   5 pub const ASSERT_PRIMARY: u32 = 8u32;
   6 #[repr(C)]
   7 pub struct ASYNC_DUPLICATE_EXTENTS_STATUS {
   8     pub Version: u32,
   9     pub State: DUPLICATE_EXTENTS_STATE,
  10     pub SourceFileOffset: u64,
  11     pub TargetFileOffset: u64,
  12     pub ByteCount: u64,
  13     pub BytesDuplicated: u64,
  14 }
  15 impl ::core::marker::Copy for ASYNC_DUPLICATE_EXTENTS_STATUS {}
  16 impl ::core::clone::Clone for ASYNC_DUPLICATE_EXTENTS_STATUS {
  17     fn clone(&self) -> Self {
  18         *self
  19     }
  20 }
  21 pub const ATAPI_ID_CMD: u32 = 161u32;
  22 #[repr(C)]
  23 pub struct BIN_COUNT {
  24     pub BinRange: BIN_RANGE,
  25     pub BinCount: u32,
  26 }
  27 impl ::core::marker::Copy for BIN_COUNT {}
  28 impl ::core::clone::Clone for BIN_COUNT {
  29     fn clone(&self) -> Self {
  30         *self
  31     }
  32 }
  33 #[repr(C)]
  34 pub struct BIN_RANGE {
  35     pub StartValue: i64,
  36     pub Length: i64,
  37 }
  38 impl ::core::marker::Copy for BIN_RANGE {}
  39 impl ::core::clone::Clone for BIN_RANGE {
  40     fn clone(&self) -> Self {
  41         *self
  42     }
  43 }
  44 #[repr(C)]
  45 pub struct BIN_RESULTS {
  46     pub NumberOfBins: u32,
  47     pub BinCounts: [BIN_COUNT; 1],
  48 }
  49 impl ::core::marker::Copy for BIN_RESULTS {}
  50 impl ::core::clone::Clone for BIN_RESULTS {
  51     fn clone(&self) -> Self {
  52         *self
  53     }
  54 }
  55 pub type BIN_TYPES = i32;
  56 pub const RequestSize: BIN_TYPES = 0i32;
  57 pub const RequestLocation: BIN_TYPES = 1i32;
  58 #[repr(C)]
  59 pub struct BOOT_AREA_INFO {
  60     pub BootSectorCount: u32,
  61     pub BootSectors: [BOOT_AREA_INFO_0; 2],
  62 }
  63 impl ::core::marker::Copy for BOOT_AREA_INFO {}
  64 impl ::core::clone::Clone for BOOT_AREA_INFO {
  65     fn clone(&self) -> Self {
  66         *self
  67     }
  68 }
  69 #[repr(C)]
  70 pub struct BOOT_AREA_INFO_0 {
  71     pub Offset: i64,
  72 }
  73 impl ::core::marker::Copy for BOOT_AREA_INFO_0 {}
  74 impl ::core::clone::Clone for BOOT_AREA_INFO_0 {
  75     fn clone(&self) -> Self {
  76         *self
  77     }
  78 }
  79 #[repr(C)]
  80 pub struct BULK_SECURITY_TEST_DATA {
  81     pub DesiredAccess: u32,
  82     pub SecurityIds: [u32; 1],
  83 }
  84 impl ::core::marker::Copy for BULK_SECURITY_TEST_DATA {}
  85 impl ::core::clone::Clone for BULK_SECURITY_TEST_DATA {
  86     fn clone(&self) -> Self {
  87         *self
  88     }
  89 }
  90 pub const CAP_ATAPI_ID_CMD: u32 = 2u32;
  91 pub const CAP_ATA_ID_CMD: u32 = 1u32;
  92 pub const CAP_SMART_CMD: u32 = 4u32;
  93 pub const CDB_SIZE: u32 = 16u32;
  94 pub type CHANGER_DEVICE_PROBLEM_TYPE = i32;
  95 pub const DeviceProblemNone: CHANGER_DEVICE_PROBLEM_TYPE = 0i32;
  96 pub const DeviceProblemHardware: CHANGER_DEVICE_PROBLEM_TYPE = 1i32;
  97 pub const DeviceProblemCHMError: CHANGER_DEVICE_PROBLEM_TYPE = 2i32;
  98 pub const DeviceProblemDoorOpen: CHANGER_DEVICE_PROBLEM_TYPE = 3i32;
  99 pub const DeviceProblemCalibrationError: CHANGER_DEVICE_PROBLEM_TYPE = 4i32;
 100 pub const DeviceProblemTargetFailure: CHANGER_DEVICE_PROBLEM_TYPE = 5i32;
 101 pub const DeviceProblemCHMMoveError: CHANGER_DEVICE_PROBLEM_TYPE = 6i32;
 102 pub const DeviceProblemCHMZeroError: CHANGER_DEVICE_PROBLEM_TYPE = 7i32;
 103 pub const DeviceProblemCartridgeInsertError: CHANGER_DEVICE_PROBLEM_TYPE = 8i32;
 104 pub const DeviceProblemPositionError: CHANGER_DEVICE_PROBLEM_TYPE = 9i32;
 105 pub const DeviceProblemSensorError: CHANGER_DEVICE_PROBLEM_TYPE = 10i32;
 106 pub const DeviceProblemCartridgeEjectError: CHANGER_DEVICE_PROBLEM_TYPE = 11i32;
 107 pub const DeviceProblemGripperError: CHANGER_DEVICE_PROBLEM_TYPE = 12i32;
 108 pub const DeviceProblemDriveError: CHANGER_DEVICE_PROBLEM_TYPE = 13i32;
 109 #[repr(C)]
 110 pub struct CHANGER_ELEMENT {
 111     pub ElementType: ELEMENT_TYPE,
 112     pub ElementAddress: u32,
 113 }
 114 impl ::core::marker::Copy for CHANGER_ELEMENT {}
 115 impl ::core::clone::Clone for CHANGER_ELEMENT {
 116     fn clone(&self) -> Self {
 117         *self
 118     }
 119 }
 120 #[repr(C)]
 121 pub struct CHANGER_ELEMENT_LIST {
 122     pub Element: CHANGER_ELEMENT,
 123     pub NumberOfElements: u32,
 124 }
 125 impl ::core::marker::Copy for CHANGER_ELEMENT_LIST {}
 126 impl ::core::clone::Clone for CHANGER_ELEMENT_LIST {
 127     fn clone(&self) -> Self {
 128         *self
 129     }
 130 }
 131 #[repr(C)]
 132 pub struct CHANGER_ELEMENT_STATUS {
 133     pub Element: CHANGER_ELEMENT,
 134     pub SrcElementAddress: CHANGER_ELEMENT,
 135     pub Flags: CHANGER_ELEMENT_STATUS_FLAGS,
 136     pub ExceptionCode: u32,
 137     pub TargetId: u8,
 138     pub Lun: u8,
 139     pub Reserved: u16,
 140     pub PrimaryVolumeID: [u8; 36],
 141     pub AlternateVolumeID: [u8; 36],
 142 }
 143 impl ::core::marker::Copy for CHANGER_ELEMENT_STATUS {}
 144 impl ::core::clone::Clone for CHANGER_ELEMENT_STATUS {
 145     fn clone(&self) -> Self {
 146         *self
 147     }
 148 }
 149 #[repr(C)]
 150 pub struct CHANGER_ELEMENT_STATUS_EX {
 151     pub Element: CHANGER_ELEMENT,
 152     pub SrcElementAddress: CHANGER_ELEMENT,
 153     pub Flags: CHANGER_ELEMENT_STATUS_FLAGS,
 154     pub ExceptionCode: u32,
 155     pub TargetId: u8,
 156     pub Lun: u8,
 157     pub Reserved: u16,
 158     pub PrimaryVolumeID: [u8; 36],
 159     pub AlternateVolumeID: [u8; 36],
 160     pub VendorIdentification: [u8; 8],
 161     pub ProductIdentification: [u8; 16],
 162     pub SerialNumber: [u8; 32],
 163 }
 164 impl ::core::marker::Copy for CHANGER_ELEMENT_STATUS_EX {}
 165 impl ::core::clone::Clone for CHANGER_ELEMENT_STATUS_EX {
 166     fn clone(&self) -> Self {
 167         *self
 168     }
 169 }
 170 pub type CHANGER_ELEMENT_STATUS_FLAGS = u32;
 171 pub const ELEMENT_STATUS_ACCESS: CHANGER_ELEMENT_STATUS_FLAGS = 8u32;
 172 pub const ELEMENT_STATUS_AVOLTAG: CHANGER_ELEMENT_STATUS_FLAGS = 536870912u32;
 173 pub const ELEMENT_STATUS_EXCEPT: CHANGER_ELEMENT_STATUS_FLAGS = 4u32;
 174 pub const ELEMENT_STATUS_EXENAB: CHANGER_ELEMENT_STATUS_FLAGS = 16u32;
 175 pub const ELEMENT_STATUS_FULL: CHANGER_ELEMENT_STATUS_FLAGS = 1u32;
 176 pub const ELEMENT_STATUS_ID_VALID: CHANGER_ELEMENT_STATUS_FLAGS = 8192u32;
 177 pub const ELEMENT_STATUS_IMPEXP: CHANGER_ELEMENT_STATUS_FLAGS = 2u32;
 178 pub const ELEMENT_STATUS_INENAB: CHANGER_ELEMENT_STATUS_FLAGS = 32u32;
 179 pub const ELEMENT_STATUS_INVERT: CHANGER_ELEMENT_STATUS_FLAGS = 4194304u32;
 180 pub const ELEMENT_STATUS_LUN_VALID: CHANGER_ELEMENT_STATUS_FLAGS = 4096u32;
 181 pub const ELEMENT_STATUS_NOT_BUS: CHANGER_ELEMENT_STATUS_FLAGS = 32768u32;
 182 pub const ELEMENT_STATUS_PVOLTAG: CHANGER_ELEMENT_STATUS_FLAGS = 268435456u32;
 183 pub const ELEMENT_STATUS_SVALID: CHANGER_ELEMENT_STATUS_FLAGS = 8388608u32;
 184 pub const ELEMENT_STATUS_PRODUCT_DATA: CHANGER_ELEMENT_STATUS_FLAGS = 64u32;
 185 #[repr(C)]
 186 #[cfg(feature = "Win32_Foundation")]
 187 pub struct CHANGER_EXCHANGE_MEDIUM {
 188     pub Transport: CHANGER_ELEMENT,
 189     pub Source: CHANGER_ELEMENT,
 190     pub Destination1: CHANGER_ELEMENT,
 191     pub Destination2: CHANGER_ELEMENT,
 192     pub Flip1: super::super::Foundation::BOOLEAN,
 193     pub Flip2: super::super::Foundation::BOOLEAN,
 194 }
 195 #[cfg(feature = "Win32_Foundation")]
 196 impl ::core::marker::Copy for CHANGER_EXCHANGE_MEDIUM {}
 197 #[cfg(feature = "Win32_Foundation")]
 198 impl ::core::clone::Clone for CHANGER_EXCHANGE_MEDIUM {
 199     fn clone(&self) -> Self {
 200         *self
 201     }
 202 }
 203 pub type CHANGER_FEATURES = u32;
 204 pub const CHANGER_BAR_CODE_SCANNER_INSTALLED: CHANGER_FEATURES = 1u32;
 205 pub const CHANGER_CARTRIDGE_MAGAZINE: CHANGER_FEATURES = 256u32;
 206 pub const CHANGER_CLEANER_ACCESS_NOT_VALID: CHANGER_FEATURES = 262144u32;
 207 pub const CHANGER_CLEANER_SLOT: CHANGER_FEATURES = 64u32;
 208 pub const CHANGER_CLOSE_IEPORT: CHANGER_FEATURES = 4u32;
 209 pub const CHANGER_DEVICE_REINITIALIZE_CAPABLE: CHANGER_FEATURES = 134217728u32;
 210 pub const CHANGER_DRIVE_CLEANING_REQUIRED: CHANGER_FEATURES = 65536u32;
 211 pub const CHANGER_DRIVE_EMPTY_ON_DOOR_ACCESS: CHANGER_FEATURES = 536870912u32;
 212 pub const CHANGER_EXCHANGE_MEDIA: CHANGER_FEATURES = 32u32;
 213 pub const CHANGER_INIT_ELEM_STAT_WITH_RANGE: CHANGER_FEATURES = 2u32;
 214 pub const CHANGER_KEYPAD_ENABLE_DISABLE: CHANGER_FEATURES = 268435456u32;
 215 pub const CHANGER_LOCK_UNLOCK: CHANGER_FEATURES = 128u32;
 216 pub const CHANGER_MEDIUM_FLIP: CHANGER_FEATURES = 512u32;
 217 pub const CHANGER_OPEN_IEPORT: CHANGER_FEATURES = 8u32;
 218 pub const CHANGER_POSITION_TO_ELEMENT: CHANGER_FEATURES = 1024u32;
 219 pub const CHANGER_PREDISMOUNT_EJECT_REQUIRED: CHANGER_FEATURES = 131072u32;
 220 pub const CHANGER_PREMOUNT_EJECT_REQUIRED: CHANGER_FEATURES = 524288u32;
 221 pub const CHANGER_REPORT_IEPORT_STATE: CHANGER_FEATURES = 2048u32;
 222 pub const CHANGER_SERIAL_NUMBER_VALID: CHANGER_FEATURES = 67108864u32;
 223 pub const CHANGER_STATUS_NON_VOLATILE: CHANGER_FEATURES = 16u32;
 224 pub const CHANGER_STORAGE_DRIVE: CHANGER_FEATURES = 4096u32;
 225 pub const CHANGER_STORAGE_IEPORT: CHANGER_FEATURES = 8192u32;
 226 pub const CHANGER_STORAGE_SLOT: CHANGER_FEATURES = 16384u32;
 227 pub const CHANGER_STORAGE_TRANSPORT: CHANGER_FEATURES = 32768u32;
 228 pub const CHANGER_VOLUME_ASSERT: CHANGER_FEATURES = 4194304u32;
 229 pub const CHANGER_VOLUME_IDENTIFICATION: CHANGER_FEATURES = 1048576u32;
 230 pub const CHANGER_VOLUME_REPLACE: CHANGER_FEATURES = 8388608u32;
 231 pub const CHANGER_VOLUME_SEARCH: CHANGER_FEATURES = 2097152u32;
 232 pub const CHANGER_VOLUME_UNDEFINE: CHANGER_FEATURES = 16777216u32;
 233 #[repr(C)]
 234 #[cfg(feature = "Win32_Foundation")]
 235 pub struct CHANGER_INITIALIZE_ELEMENT_STATUS {
 236     pub ElementList: CHANGER_ELEMENT_LIST,
 237     pub BarCodeScan: super::super::Foundation::BOOLEAN,
 238 }
 239 #[cfg(feature = "Win32_Foundation")]
 240 impl ::core::marker::Copy for CHANGER_INITIALIZE_ELEMENT_STATUS {}
 241 #[cfg(feature = "Win32_Foundation")]
 242 impl ::core::clone::Clone for CHANGER_INITIALIZE_ELEMENT_STATUS {
 243     fn clone(&self) -> Self {
 244         *self
 245     }
 246 }
 247 #[repr(C)]
 248 #[cfg(feature = "Win32_Foundation")]
 249 pub struct CHANGER_MOVE_MEDIUM {
 250     pub Transport: CHANGER_ELEMENT,
 251     pub Source: CHANGER_ELEMENT,
 252     pub Destination: CHANGER_ELEMENT,
 253     pub Flip: super::super::Foundation::BOOLEAN,
 254 }
 255 #[cfg(feature = "Win32_Foundation")]
 256 impl ::core::marker::Copy for CHANGER_MOVE_MEDIUM {}
 257 #[cfg(feature = "Win32_Foundation")]
 258 impl ::core::clone::Clone for CHANGER_MOVE_MEDIUM {
 259     fn clone(&self) -> Self {
 260         *self
 261     }
 262 }
 263 #[repr(C)]
 264 pub struct CHANGER_PRODUCT_DATA {
 265     pub VendorId: [u8; 8],
 266     pub ProductId: [u8; 16],
 267     pub Revision: [u8; 4],
 268     pub SerialNumber: [u8; 32],
 269     pub DeviceType: u8,
 270 }
 271 impl ::core::marker::Copy for CHANGER_PRODUCT_DATA {}
 272 impl ::core::clone::Clone for CHANGER_PRODUCT_DATA {
 273     fn clone(&self) -> Self {
 274         *self
 275     }
 276 }
 277 #[repr(C)]
 278 #[cfg(feature = "Win32_Foundation")]
 279 pub struct CHANGER_READ_ELEMENT_STATUS {
 280     pub ElementList: CHANGER_ELEMENT_LIST,
 281     pub VolumeTagInfo: super::super::Foundation::BOOLEAN,
 282 }
 283 #[cfg(feature = "Win32_Foundation")]
 284 impl ::core::marker::Copy for CHANGER_READ_ELEMENT_STATUS {}
 285 #[cfg(feature = "Win32_Foundation")]
 286 impl ::core::clone::Clone for CHANGER_READ_ELEMENT_STATUS {
 287     fn clone(&self) -> Self {
 288         *self
 289     }
 290 }
 291 pub const CHANGER_RESERVED_BIT: u32 = 2147483648u32;
 292 #[repr(C)]
 293 pub struct CHANGER_SEND_VOLUME_TAG_INFORMATION {
 294     pub StartingElement: CHANGER_ELEMENT,
 295     pub ActionCode: u32,
 296     pub VolumeIDTemplate: [u8; 40],
 297 }
 298 impl ::core::marker::Copy for CHANGER_SEND_VOLUME_TAG_INFORMATION {}
 299 impl ::core::clone::Clone for CHANGER_SEND_VOLUME_TAG_INFORMATION {
 300     fn clone(&self) -> Self {
 301         *self
 302     }
 303 }
 304 #[repr(C)]
 305 pub struct CHANGER_SET_ACCESS {
 306     pub Element: CHANGER_ELEMENT,
 307     pub Control: u32,
 308 }
 309 impl ::core::marker::Copy for CHANGER_SET_ACCESS {}
 310 impl ::core::clone::Clone for CHANGER_SET_ACCESS {
 311     fn clone(&self) -> Self {
 312         *self
 313     }
 314 }
 315 #[repr(C)]
 316 #[cfg(feature = "Win32_Foundation")]
 317 pub struct CHANGER_SET_POSITION {
 318     pub Transport: CHANGER_ELEMENT,
 319     pub Destination: CHANGER_ELEMENT,
 320     pub Flip: super::super::Foundation::BOOLEAN,
 321 }
 322 #[cfg(feature = "Win32_Foundation")]
 323 impl ::core::marker::Copy for CHANGER_SET_POSITION {}
 324 #[cfg(feature = "Win32_Foundation")]
 325 impl ::core::clone::Clone for CHANGER_SET_POSITION {
 326     fn clone(&self) -> Self {
 327         *self
 328     }
 329 }
 330 pub const CHANGER_TO_DRIVE: u32 = 8u32;
 331 pub const CHANGER_TO_IEPORT: u32 = 4u32;
 332 pub const CHANGER_TO_SLOT: u32 = 2u32;
 333 pub const CHANGER_TO_TRANSPORT: u32 = 1u32;
 334 pub const CHECKSUM_TYPE_CRC32: u32 = 1u32;
 335 pub const CHECKSUM_TYPE_CRC64: u32 = 2u32;
 336 pub const CHECKSUM_TYPE_ECC: u32 = 3u32;
 337 pub const CHECKSUM_TYPE_FIRST_UNUSED_TYPE: u32 = 4u32;
 338 pub const CHECKSUM_TYPE_NONE: u32 = 0u32;
 339 pub const CHECKSUM_TYPE_UNCHANGED: i32 = -1i32;
 340 #[repr(C)]
 341 pub struct CLASS_MEDIA_CHANGE_CONTEXT {
 342     pub MediaChangeCount: u32,
 343     pub NewState: u32,
 344 }
 345 impl ::core::marker::Copy for CLASS_MEDIA_CHANGE_CONTEXT {}
 346 impl ::core::clone::Clone for CLASS_MEDIA_CHANGE_CONTEXT {
 347     fn clone(&self) -> Self {
 348         *self
 349     }
 350 }
 351 #[repr(C)]
 352 pub struct CLUSTER_RANGE {
 353     pub StartingCluster: i64,
 354     pub ClusterCount: i64,
 355 }
 356 impl ::core::marker::Copy for CLUSTER_RANGE {}
 357 impl ::core::clone::Clone for CLUSTER_RANGE {
 358     fn clone(&self) -> Self {
 359         *self
 360     }
 361 }
 362 pub const CONTAINER_ROOT_INFO_FLAG_BIND_DO_NOT_MAP_NAME: u32 = 256u32;
 363 pub const CONTAINER_ROOT_INFO_FLAG_BIND_EXCEPTION_ROOT: u32 = 128u32;
 364 pub const CONTAINER_ROOT_INFO_FLAG_BIND_ROOT: u32 = 32u32;
 365 pub const CONTAINER_ROOT_INFO_FLAG_BIND_TARGET_ROOT: u32 = 64u32;
 366 pub const CONTAINER_ROOT_INFO_FLAG_LAYER_ROOT: u32 = 2u32;
 367 pub const CONTAINER_ROOT_INFO_FLAG_SCRATCH_ROOT: u32 = 1u32;
 368 pub const CONTAINER_ROOT_INFO_FLAG_UNION_LAYER_ROOT: u32 = 512u32;
 369 pub const CONTAINER_ROOT_INFO_FLAG_VIRTUALIZATION_EXCEPTION_ROOT: u32 = 16u32;
 370 pub const CONTAINER_ROOT_INFO_FLAG_VIRTUALIZATION_ROOT: u32 = 4u32;
 371 pub const CONTAINER_ROOT_INFO_FLAG_VIRTUALIZATION_TARGET_ROOT: u32 = 8u32;
 372 #[repr(C)]
 373 pub struct CONTAINER_ROOT_INFO_INPUT {
 374     pub Flags: u32,
 375 }
 376 impl ::core::marker::Copy for CONTAINER_ROOT_INFO_INPUT {}
 377 impl ::core::clone::Clone for CONTAINER_ROOT_INFO_INPUT {
 378     fn clone(&self) -> Self {
 379         *self
 380     }
 381 }
 382 #[repr(C)]
 383 pub struct CONTAINER_ROOT_INFO_OUTPUT {
 384     pub ContainerRootIdLength: u16,
 385     pub ContainerRootId: [u8; 1],
 386 }
 387 impl ::core::marker::Copy for CONTAINER_ROOT_INFO_OUTPUT {}
 388 impl ::core::clone::Clone for CONTAINER_ROOT_INFO_OUTPUT {
 389     fn clone(&self) -> Self {
 390         *self
 391     }
 392 }
 393 pub const CONTAINER_ROOT_INFO_VALID_FLAGS: u32 = 1023u32;
 394 #[repr(C)]
 395 pub struct CONTAINER_VOLUME_STATE {
 396     pub Flags: u32,
 397 }
 398 impl ::core::marker::Copy for CONTAINER_VOLUME_STATE {}
 399 impl ::core::clone::Clone for CONTAINER_VOLUME_STATE {
 400     fn clone(&self) -> Self {
 401         *self
 402     }
 403 }
 404 pub const CONTAINER_VOLUME_STATE_HOSTING_CONTAINER: u32 = 1u32;
 405 pub const COPYFILE_SIS_FLAGS: u32 = 3u32;
 406 pub const COPYFILE_SIS_LINK: u32 = 1u32;
 407 pub const COPYFILE_SIS_REPLACE: u32 = 2u32;
 408 #[repr(C)]
 409 pub struct CREATE_DISK {
 410     pub PartitionStyle: PARTITION_STYLE,
 411     pub Anonymous: CREATE_DISK_0,
 412 }
 413 impl ::core::marker::Copy for CREATE_DISK {}
 414 impl ::core::clone::Clone for CREATE_DISK {
 415     fn clone(&self) -> Self {
 416         *self
 417     }
 418 }
 419 #[repr(C)]
 420 pub union CREATE_DISK_0 {
 421     pub Mbr: CREATE_DISK_MBR,
 422     pub Gpt: CREATE_DISK_GPT,
 423 }
 424 impl ::core::marker::Copy for CREATE_DISK_0 {}
 425 impl ::core::clone::Clone for CREATE_DISK_0 {
 426     fn clone(&self) -> Self {
 427         *self
 428     }
 429 }
 430 #[repr(C)]
 431 pub struct CREATE_DISK_GPT {
 432     pub DiskId: ::windows_sys::core::GUID,
 433     pub MaxPartitionCount: u32,
 434 }
 435 impl ::core::marker::Copy for CREATE_DISK_GPT {}
 436 impl ::core::clone::Clone for CREATE_DISK_GPT {
 437     fn clone(&self) -> Self {
 438         *self
 439     }
 440 }
 441 #[repr(C)]
 442 pub struct CREATE_DISK_MBR {
 443     pub Signature: u32,
 444 }
 445 impl ::core::marker::Copy for CREATE_DISK_MBR {}
 446 impl ::core::clone::Clone for CREATE_DISK_MBR {
 447     fn clone(&self) -> Self {
 448         *self
 449     }
 450 }
 451 #[repr(C)]
 452 pub struct CREATE_USN_JOURNAL_DATA {
 453     pub MaximumSize: u64,
 454     pub AllocationDelta: u64,
 455 }
 456 impl ::core::marker::Copy for CREATE_USN_JOURNAL_DATA {}
 457 impl ::core::clone::Clone for CREATE_USN_JOURNAL_DATA {
 458     fn clone(&self) -> Self {
 459         *self
 460     }
 461 }
 462 pub type CSVFS_DISK_CONNECTIVITY = i32;
 463 pub const CsvFsDiskConnectivityNone: CSVFS_DISK_CONNECTIVITY = 0i32;
 464 pub const CsvFsDiskConnectivityMdsNodeOnly: CSVFS_DISK_CONNECTIVITY = 1i32;
 465 pub const CsvFsDiskConnectivitySubsetOfNodes: CSVFS_DISK_CONNECTIVITY = 2i32;
 466 pub const CsvFsDiskConnectivityAllNodes: CSVFS_DISK_CONNECTIVITY = 3i32;
 467 pub type CSV_CONTROL_OP = i32;
 468 pub const CsvControlStartRedirectFile: CSV_CONTROL_OP = 2i32;
 469 pub const CsvControlStopRedirectFile: CSV_CONTROL_OP = 3i32;
 470 pub const CsvControlQueryRedirectState: CSV_CONTROL_OP = 4i32;
 471 pub const CsvControlQueryFileRevision: CSV_CONTROL_OP = 6i32;
 472 pub const CsvControlQueryMdsPath: CSV_CONTROL_OP = 8i32;
 473 pub const CsvControlQueryFileRevisionFileId128: CSV_CONTROL_OP = 9i32;
 474 pub const CsvControlQueryVolumeRedirectState: CSV_CONTROL_OP = 10i32;
 475 pub const CsvControlEnableUSNRangeModificationTracking: CSV_CONTROL_OP = 13i32;
 476 pub const CsvControlMarkHandleLocalVolumeMount: CSV_CONTROL_OP = 14i32;
 477 pub const CsvControlUnmarkHandleLocalVolumeMount: CSV_CONTROL_OP = 15i32;
 478 pub const CsvControlGetCsvFsMdsPathV2: CSV_CONTROL_OP = 18i32;
 479 pub const CsvControlDisableCaching: CSV_CONTROL_OP = 19i32;
 480 pub const CsvControlEnableCaching: CSV_CONTROL_OP = 20i32;
 481 pub const CsvControlStartForceDFO: CSV_CONTROL_OP = 21i32;
 482 pub const CsvControlStopForceDFO: CSV_CONTROL_OP = 22i32;
 483 pub const CsvControlQueryMdsPathNoPause: CSV_CONTROL_OP = 23i32;
 484 pub const CsvControlSetVolumeId: CSV_CONTROL_OP = 24i32;
 485 pub const CsvControlQueryVolumeId: CSV_CONTROL_OP = 25i32;
 486 #[repr(C)]
 487 pub struct CSV_CONTROL_PARAM {
 488     pub Operation: CSV_CONTROL_OP,
 489     pub Unused: i64,
 490 }
 491 impl ::core::marker::Copy for CSV_CONTROL_PARAM {}
 492 impl ::core::clone::Clone for CSV_CONTROL_PARAM {
 493     fn clone(&self) -> Self {
 494         *self
 495     }
 496 }
 497 pub const CSV_INVALID_DEVICE_NUMBER: u32 = 4294967295u32;
 498 #[repr(C)]
 499 #[cfg(feature = "Win32_Foundation")]
 500 pub struct CSV_IS_OWNED_BY_CSVFS {
 501     pub OwnedByCSVFS: super::super::Foundation::BOOLEAN,
 502 }
 503 #[cfg(feature = "Win32_Foundation")]
 504 impl ::core::marker::Copy for CSV_IS_OWNED_BY_CSVFS {}
 505 #[cfg(feature = "Win32_Foundation")]
 506 impl ::core::clone::Clone for CSV_IS_OWNED_BY_CSVFS {
 507     fn clone(&self) -> Self {
 508         *self
 509     }
 510 }
 511 pub const CSV_MGMTLOCK_CHECK_VOLUME_REDIRECTED: u32 = 1u32;
 512 #[repr(C)]
 513 pub struct CSV_MGMT_LOCK {
 514     pub Flags: u32,
 515 }
 516 impl ::core::marker::Copy for CSV_MGMT_LOCK {}
 517 impl ::core::clone::Clone for CSV_MGMT_LOCK {
 518     fn clone(&self) -> Self {
 519         *self
 520     }
 521 }
 522 #[repr(C)]
 523 pub struct CSV_NAMESPACE_INFO {
 524     pub Version: u32,
 525     pub DeviceNumber: u32,
 526     pub StartingOffset: i64,
 527     pub SectorSize: u32,
 528 }
 529 impl ::core::marker::Copy for CSV_NAMESPACE_INFO {}
 530 impl ::core::clone::Clone for CSV_NAMESPACE_INFO {
 531     fn clone(&self) -> Self {
 532         *self
 533     }
 534 }
 535 #[repr(C)]
 536 pub struct CSV_QUERY_FILE_REVISION {
 537     pub FileId: i64,
 538     pub FileRevision: [i64; 3],
 539 }
 540 impl ::core::marker::Copy for CSV_QUERY_FILE_REVISION {}
 541 impl ::core::clone::Clone for CSV_QUERY_FILE_REVISION {
 542     fn clone(&self) -> Self {
 543         *self
 544     }
 545 }
 546 #[repr(C)]
 547 #[cfg(feature = "Win32_Storage_FileSystem")]
 548 pub struct CSV_QUERY_FILE_REVISION_FILE_ID_128 {
 549     pub FileId: super::super::Storage::FileSystem::FILE_ID_128,
 550     pub FileRevision: [i64; 3],
 551 }
 552 #[cfg(feature = "Win32_Storage_FileSystem")]
 553 impl ::core::marker::Copy for CSV_QUERY_FILE_REVISION_FILE_ID_128 {}
 554 #[cfg(feature = "Win32_Storage_FileSystem")]
 555 impl ::core::clone::Clone for CSV_QUERY_FILE_REVISION_FILE_ID_128 {
 556     fn clone(&self) -> Self {
 557         *self
 558     }
 559 }
 560 #[repr(C)]
 561 pub struct CSV_QUERY_MDS_PATH {
 562     pub MdsNodeId: u32,
 563     pub DsNodeId: u32,
 564     pub PathLength: u32,
 565     pub Path: [u16; 1],
 566 }
 567 impl ::core::marker::Copy for CSV_QUERY_MDS_PATH {}
 568 impl ::core::clone::Clone for CSV_QUERY_MDS_PATH {
 569     fn clone(&self) -> Self {
 570         *self
 571     }
 572 }
 573 pub const CSV_QUERY_MDS_PATH_FLAG_CSV_DIRECT_IO_ENABLED: u32 = 2u32;
 574 pub const CSV_QUERY_MDS_PATH_FLAG_SMB_BYPASS_CSV_ENABLED: u32 = 4u32;
 575 pub const CSV_QUERY_MDS_PATH_FLAG_STORAGE_ON_THIS_NODE_IS_CONNECTED: u32 = 1u32;
 576 #[repr(C)]
 577 pub struct CSV_QUERY_MDS_PATH_V2 {
 578     pub Version: i64,
 579     pub RequiredSize: u32,
 580     pub MdsNodeId: u32,
 581     pub DsNodeId: u32,
 582     pub Flags: u32,
 583     pub DiskConnectivity: CSVFS_DISK_CONNECTIVITY,
 584     pub VolumeId: ::windows_sys::core::GUID,
 585     pub IpAddressOffset: u32,
 586     pub IpAddressLength: u32,
 587     pub PathOffset: u32,
 588     pub PathLength: u32,
 589 }
 590 impl ::core::marker::Copy for CSV_QUERY_MDS_PATH_V2 {}
 591 impl ::core::clone::Clone for CSV_QUERY_MDS_PATH_V2 {
 592     fn clone(&self) -> Self {
 593         *self
 594     }
 595 }
 596 pub const CSV_QUERY_MDS_PATH_V2_VERSION_1: u32 = 1u32;
 597 #[repr(C)]
 598 #[cfg(feature = "Win32_Foundation")]
 599 pub struct CSV_QUERY_REDIRECT_STATE {
 600     pub MdsNodeId: u32,
 601     pub DsNodeId: u32,
 602     pub FileRedirected: super::super::Foundation::BOOLEAN,
 603 }
 604 #[cfg(feature = "Win32_Foundation")]
 605 impl ::core::marker::Copy for CSV_QUERY_REDIRECT_STATE {}
 606 #[cfg(feature = "Win32_Foundation")]
 607 impl ::core::clone::Clone for CSV_QUERY_REDIRECT_STATE {
 608     fn clone(&self) -> Self {
 609         *self
 610     }
 611 }
 612 #[repr(C)]
 613 pub struct CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT {
 614     pub VetoedFromAltitudeIntegral: u64,
 615     pub VetoedFromAltitudeDecimal: u64,
 616     pub Reason: [u16; 256],
 617 }
 618 impl ::core::marker::Copy for CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT {}
 619 impl ::core::clone::Clone for CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT {
 620     fn clone(&self) -> Self {
 621         *self
 622     }
 623 }
 624 #[repr(C)]
 625 pub struct CSV_QUERY_VOLUME_ID {
 626     pub VolumeId: ::windows_sys::core::GUID,
 627 }
 628 impl ::core::marker::Copy for CSV_QUERY_VOLUME_ID {}
 629 impl ::core::clone::Clone for CSV_QUERY_VOLUME_ID {
 630     fn clone(&self) -> Self {
 631         *self
 632     }
 633 }
 634 #[repr(C)]
 635 #[cfg(feature = "Win32_Foundation")]
 636 pub struct CSV_QUERY_VOLUME_REDIRECT_STATE {
 637     pub MdsNodeId: u32,
 638     pub DsNodeId: u32,
 639     pub IsDiskConnected: super::super::Foundation::BOOLEAN,
 640     pub ClusterEnableDirectIo: super::super::Foundation::BOOLEAN,
 641     pub DiskConnectivity: CSVFS_DISK_CONNECTIVITY,
 642 }
 643 #[cfg(feature = "Win32_Foundation")]
 644 impl ::core::marker::Copy for CSV_QUERY_VOLUME_REDIRECT_STATE {}
 645 #[cfg(feature = "Win32_Foundation")]
 646 impl ::core::clone::Clone for CSV_QUERY_VOLUME_REDIRECT_STATE {
 647     fn clone(&self) -> Self {
 648         *self
 649     }
 650 }
 651 #[repr(C)]
 652 pub struct CSV_SET_VOLUME_ID {
 653     pub VolumeId: ::windows_sys::core::GUID,
 654 }
 655 impl ::core::marker::Copy for CSV_SET_VOLUME_ID {}
 656 impl ::core::clone::Clone for CSV_SET_VOLUME_ID {
 657     fn clone(&self) -> Self {
 658         *self
 659     }
 660 }
 661 pub const DAX_ALLOC_ALIGNMENT_FLAG_FALLBACK_SPECIFIED: u32 = 2u32;
 662 pub const DAX_ALLOC_ALIGNMENT_FLAG_MANDATORY: u32 = 1u32;
 663 pub const DDUMP_FLAG_DATA_READ_FROM_DEVICE: u32 = 1u32;
 664 #[repr(C)]
 665 #[cfg(feature = "Win32_Foundation")]
 666 pub struct DECRYPTION_STATUS_BUFFER {
 667     pub NoEncryptedStreams: super::super::Foundation::BOOLEAN,
 668 }
 669 #[cfg(feature = "Win32_Foundation")]
 670 impl ::core::marker::Copy for DECRYPTION_STATUS_BUFFER {}
 671 #[cfg(feature = "Win32_Foundation")]
 672 impl ::core::clone::Clone for DECRYPTION_STATUS_BUFFER {
 673     fn clone(&self) -> Self {
 674         *self
 675     }
 676 }
 677 #[repr(C)]
 678 pub struct DELETE_USN_JOURNAL_DATA {
 679     pub UsnJournalID: u64,
 680     pub DeleteFlags: USN_DELETE_FLAGS,
 681 }
 682 impl ::core::marker::Copy for DELETE_USN_JOURNAL_DATA {}
 683 impl ::core::clone::Clone for DELETE_USN_JOURNAL_DATA {
 684     fn clone(&self) -> Self {
 685         *self
 686     }
 687 }
 688 pub type DETECTION_TYPE = i32;
 689 pub const DetectNone: DETECTION_TYPE = 0i32;
 690 pub const DetectInt13: DETECTION_TYPE = 1i32;
 691 pub const DetectExInt13: DETECTION_TYPE = 2i32;
 692 pub const DEVICEDUMP_CAP_PRIVATE_SECTION: u32 = 1u32;
 693 pub const DEVICEDUMP_CAP_RESTRICTED_SECTION: u32 = 2u32;
 694 pub const DEVICEDUMP_MAX_IDSTRING: u32 = 32u32;
 695 #[repr(C, packed(1))]
 696 pub struct DEVICEDUMP_PRIVATE_SUBSECTION {
 697     pub dwFlags: u32,
 698     pub GPLogId: GP_LOG_PAGE_DESCRIPTOR,
 699     pub bData: [u8; 1],
 700 }
 701 impl ::core::marker::Copy for DEVICEDUMP_PRIVATE_SUBSECTION {}
 702 impl ::core::clone::Clone for DEVICEDUMP_PRIVATE_SUBSECTION {
 703     fn clone(&self) -> Self {
 704         *self
 705     }
 706 }
 707 #[repr(C, packed(1))]
 708 #[cfg(feature = "Win32_Foundation")]
 709 pub struct DEVICEDUMP_PUBLIC_SUBSECTION {
 710     pub dwFlags: u32,
 711     pub GPLogTable: [GP_LOG_PAGE_DESCRIPTOR; 16],
 712     pub szDescription: [super::super::Foundation::CHAR; 16],
 713     pub bData: [u8; 1],
 714 }
 715 #[cfg(feature = "Win32_Foundation")]
 716 impl ::core::marker::Copy for DEVICEDUMP_PUBLIC_SUBSECTION {}
 717 #[cfg(feature = "Win32_Foundation")]
 718 impl ::core::clone::Clone for DEVICEDUMP_PUBLIC_SUBSECTION {
 719     fn clone(&self) -> Self {
 720         *self
 721     }
 722 }
 723 #[repr(C)]
 724 pub struct DEVICEDUMP_RESTRICTED_SUBSECTION {
 725     pub bData: [u8; 1],
 726 }
 727 impl ::core::marker::Copy for DEVICEDUMP_RESTRICTED_SUBSECTION {}
 728 impl ::core::clone::Clone for DEVICEDUMP_RESTRICTED_SUBSECTION {
 729     fn clone(&self) -> Self {
 730         *self
 731     }
 732 }
 733 #[repr(C, packed(1))]
 734 pub struct DEVICEDUMP_SECTION_HEADER {
 735     pub guidDeviceDataId: ::windows_sys::core::GUID,
 736     pub sOrganizationID: [u8; 16],
 737     pub dwFirmwareRevision: u32,
 738     pub sModelNumber: [u8; 32],
 739     pub szDeviceManufacturingID: [u8; 32],
 740     pub dwFlags: u32,
 741     pub bRestrictedPrivateDataVersion: u32,
 742     pub dwFirmwareIssueId: u32,
 743     pub szIssueDescriptionString: [u8; 132],
 744 }
 745 impl ::core::marker::Copy for DEVICEDUMP_SECTION_HEADER {}
 746 impl ::core::clone::Clone for DEVICEDUMP_SECTION_HEADER {
 747     fn clone(&self) -> Self {
 748         *self
 749     }
 750 }
 751 #[repr(C, packed(1))]
 752 pub struct DEVICEDUMP_STORAGEDEVICE_DATA {
 753     pub Descriptor: DEVICEDUMP_STRUCTURE_VERSION,
 754     pub SectionHeader: DEVICEDUMP_SECTION_HEADER,
 755     pub dwBufferSize: u32,
 756     pub dwReasonForCollection: u32,
 757     pub PublicData: DEVICEDUMP_SUBSECTION_POINTER,
 758     pub RestrictedData: DEVICEDUMP_SUBSECTION_POINTER,
 759     pub PrivateData: DEVICEDUMP_SUBSECTION_POINTER,
 760 }
 761 impl ::core::marker::Copy for DEVICEDUMP_STORAGEDEVICE_DATA {}
 762 impl ::core::clone::Clone for DEVICEDUMP_STORAGEDEVICE_DATA {
 763     fn clone(&self) -> Self {
 764         *self
 765     }
 766 }
 767 #[repr(C, packed(1))]
 768 pub struct DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP {
 769     pub Descriptor: DEVICEDUMP_STRUCTURE_VERSION,
 770     pub dwReasonForCollection: u32,
 771     pub cDriverName: [u8; 16],
 772     pub uiNumRecords: u32,
 773     pub RecordArray: [DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD; 1],
 774 }
 775 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP {}
 776 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP {
 777     fn clone(&self) -> Self {
 778         *self
 779     }
 780 }
 781 #[repr(C, packed(1))]
 782 pub struct DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD {
 783     pub Cdb: [u8; 16],
 784     pub Command: [u8; 16],
 785     pub StartTime: u64,
 786     pub EndTime: u64,
 787     pub OperationStatus: u32,
 788     pub OperationError: u32,
 789     pub StackSpecific: DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0,
 790 }
 791 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD {}
 792 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD {
 793     fn clone(&self) -> Self {
 794         *self
 795     }
 796 }
 797 #[repr(C)]
 798 pub union DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0 {
 799     pub ExternalStack: DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_1,
 800     pub AtaPort: DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_0,
 801     pub StorPort: DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_2,
 802 }
 803 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0 {}
 804 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0 {
 805     fn clone(&self) -> Self {
 806         *self
 807     }
 808 }
 809 #[repr(C, packed(1))]
 810 pub struct DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_0 {
 811     pub dwAtaPortSpecific: u32,
 812 }
 813 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_0 {}
 814 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_0 {
 815     fn clone(&self) -> Self {
 816         *self
 817     }
 818 }
 819 #[repr(C, packed(1))]
 820 pub struct DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_1 {
 821     pub dwReserved: u32,
 822 }
 823 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_1 {}
 824 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_1 {
 825     fn clone(&self) -> Self {
 826         *self
 827     }
 828 }
 829 #[repr(C, packed(1))]
 830 pub struct DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_2 {
 831     pub SrbTag: u32,
 832 }
 833 impl ::core::marker::Copy for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_2 {}
 834 impl ::core::clone::Clone for DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD_0_2 {
 835     fn clone(&self) -> Self {
 836         *self
 837     }
 838 }
 839 #[repr(C, packed(1))]
 840 pub struct DEVICEDUMP_STRUCTURE_VERSION {
 841     pub dwSignature: u32,
 842     pub dwVersion: u32,
 843     pub dwSize: u32,
 844 }
 845 impl ::core::marker::Copy for DEVICEDUMP_STRUCTURE_VERSION {}
 846 impl ::core::clone::Clone for DEVICEDUMP_STRUCTURE_VERSION {
 847     fn clone(&self) -> Self {
 848         *self
 849     }
 850 }
 851 pub const DEVICEDUMP_STRUCTURE_VERSION_V1: u32 = 1u32;
 852 #[repr(C, packed(1))]
 853 pub struct DEVICEDUMP_SUBSECTION_POINTER {
 854     pub dwSize: u32,
 855     pub dwFlags: u32,
 856     pub dwOffset: u32,
 857 }
 858 impl ::core::marker::Copy for DEVICEDUMP_SUBSECTION_POINTER {}
 859 impl ::core::clone::Clone for DEVICEDUMP_SUBSECTION_POINTER {
 860     fn clone(&self) -> Self {
 861         *self
 862     }
 863 }
 864 #[repr(C)]
 865 pub struct DEVICE_COPY_OFFLOAD_DESCRIPTOR {
 866     pub Version: u32,
 867     pub Size: u32,
 868     pub MaximumTokenLifetime: u32,
 869     pub DefaultTokenLifetime: u32,
 870     pub MaximumTransferSize: u64,
 871     pub OptimalTransferCount: u64,
 872     pub MaximumDataDescriptors: u32,
 873     pub MaximumTransferLengthPerDescriptor: u32,
 874     pub OptimalTransferLengthPerDescriptor: u32,
 875     pub OptimalTransferLengthGranularity: u16,
 876     pub Reserved: [u8; 2],
 877 }
 878 impl ::core::marker::Copy for DEVICE_COPY_OFFLOAD_DESCRIPTOR {}
 879 impl ::core::clone::Clone for DEVICE_COPY_OFFLOAD_DESCRIPTOR {
 880     fn clone(&self) -> Self {
 881         *self
 882     }
 883 }
 884 #[repr(C)]
 885 pub struct DEVICE_DATA_SET_LBP_STATE_PARAMETERS {
 886     pub Version: u32,
 887     pub Size: u32,
 888     pub Flags: u32,
 889     pub OutputVersion: u32,
 890 }
 891 impl ::core::marker::Copy for DEVICE_DATA_SET_LBP_STATE_PARAMETERS {}
 892 impl ::core::clone::Clone for DEVICE_DATA_SET_LBP_STATE_PARAMETERS {
 893     fn clone(&self) -> Self {
 894         *self
 895     }
 896 }
 897 pub const DEVICE_DATA_SET_LBP_STATE_PARAMETERS_VERSION_V1: u32 = 1u32;
 898 #[repr(C)]
 899 pub struct DEVICE_DATA_SET_LB_PROVISIONING_STATE {
 900     pub Size: u32,
 901     pub Version: u32,
 902     pub SlabSizeInBytes: u64,
 903     pub SlabOffsetDeltaInBytes: u32,
 904     pub SlabAllocationBitMapBitCount: u32,
 905     pub SlabAllocationBitMapLength: u32,
 906     pub SlabAllocationBitMap: [u32; 1],
 907 }
 908 impl ::core::marker::Copy for DEVICE_DATA_SET_LB_PROVISIONING_STATE {}
 909 impl ::core::clone::Clone for DEVICE_DATA_SET_LB_PROVISIONING_STATE {
 910     fn clone(&self) -> Self {
 911         *self
 912     }
 913 }
 914 #[repr(C)]
 915 pub struct DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 {
 916     pub Size: u32,
 917     pub Version: u32,
 918     pub SlabSizeInBytes: u64,
 919     pub SlabOffsetDeltaInBytes: u64,
 920     pub SlabAllocationBitMapBitCount: u32,
 921     pub SlabAllocationBitMapLength: u32,
 922     pub SlabAllocationBitMap: [u32; 1],
 923 }
 924 impl ::core::marker::Copy for DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 {}
 925 impl ::core::clone::Clone for DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 {
 926     fn clone(&self) -> Self {
 927         *self
 928     }
 929 }
 930 #[repr(C)]
 931 pub struct DEVICE_DATA_SET_RANGE {
 932     pub StartingOffset: i64,
 933     pub LengthInBytes: u64,
 934 }
 935 impl ::core::marker::Copy for DEVICE_DATA_SET_RANGE {}
 936 impl ::core::clone::Clone for DEVICE_DATA_SET_RANGE {
 937     fn clone(&self) -> Self {
 938         *self
 939     }
 940 }
 941 #[repr(C)]
 942 pub struct DEVICE_DATA_SET_REPAIR_OUTPUT {
 943     pub ParityExtent: DEVICE_DATA_SET_RANGE,
 944 }
 945 impl ::core::marker::Copy for DEVICE_DATA_SET_REPAIR_OUTPUT {}
 946 impl ::core::clone::Clone for DEVICE_DATA_SET_REPAIR_OUTPUT {
 947     fn clone(&self) -> Self {
 948         *self
 949     }
 950 }
 951 #[repr(C)]
 952 pub struct DEVICE_DATA_SET_REPAIR_PARAMETERS {
 953     pub NumberOfRepairCopies: u32,
 954     pub SourceCopy: u32,
 955     pub RepairCopies: [u32; 1],
 956 }
 957 impl ::core::marker::Copy for DEVICE_DATA_SET_REPAIR_PARAMETERS {}
 958 impl ::core::clone::Clone for DEVICE_DATA_SET_REPAIR_PARAMETERS {
 959     fn clone(&self) -> Self {
 960         *self
 961     }
 962 }
 963 #[repr(C)]
 964 pub struct DEVICE_DATA_SET_SCRUB_EX_OUTPUT {
 965     pub BytesProcessed: u64,
 966     pub BytesRepaired: u64,
 967     pub BytesFailed: u64,
 968     pub ParityExtent: DEVICE_DATA_SET_RANGE,
 969     pub BytesScrubbed: u64,
 970 }
 971 impl ::core::marker::Copy for DEVICE_DATA_SET_SCRUB_EX_OUTPUT {}
 972 impl ::core::clone::Clone for DEVICE_DATA_SET_SCRUB_EX_OUTPUT {
 973     fn clone(&self) -> Self {
 974         *self
 975     }
 976 }
 977 #[repr(C)]
 978 pub struct DEVICE_DATA_SET_SCRUB_OUTPUT {
 979     pub BytesProcessed: u64,
 980     pub BytesRepaired: u64,
 981     pub BytesFailed: u64,
 982 }
 983 impl ::core::marker::Copy for DEVICE_DATA_SET_SCRUB_OUTPUT {}
 984 impl ::core::clone::Clone for DEVICE_DATA_SET_SCRUB_OUTPUT {
 985     fn clone(&self) -> Self {
 986         *self
 987     }
 988 }
 989 #[repr(C)]
 990 pub struct DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT {
 991     pub TopologyRangeBytes: u64,
 992     pub TopologyId: [u8; 16],
 993 }
 994 impl ::core::marker::Copy for DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT {}
 995 impl ::core::clone::Clone for DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT {
 996     fn clone(&self) -> Self {
 997         *self
 998     }
 999 }
1000 #[repr(C)]
1001 pub struct DEVICE_DSM_CONVERSION_OUTPUT {
1002     pub Version: u32,
1003     pub Source: ::windows_sys::core::GUID,
1004 }
1005 impl ::core::marker::Copy for DEVICE_DSM_CONVERSION_OUTPUT {}
1006 impl ::core::clone::Clone for DEVICE_DSM_CONVERSION_OUTPUT {
1007     fn clone(&self) -> Self {
1008         *self
1009     }
1010 }
1011 #[repr(C)]
1012 #[cfg(feature = "Win32_Foundation")]
1013 pub struct DEVICE_DSM_DEFINITION {
1014     pub Action: u32,
1015     pub SingleRange: super::super::Foundation::BOOLEAN,
1016     pub ParameterBlockAlignment: u32,
1017     pub ParameterBlockLength: u32,
1018     pub HasOutput: super::super::Foundation::BOOLEAN,
1019     pub OutputBlockAlignment: u32,
1020     pub OutputBlockLength: u32,
1021 }
1022 #[cfg(feature = "Win32_Foundation")]
1023 impl ::core::marker::Copy for DEVICE_DSM_DEFINITION {}
1024 #[cfg(feature = "Win32_Foundation")]
1025 impl ::core::clone::Clone for DEVICE_DSM_DEFINITION {
1026     fn clone(&self) -> Self {
1027         *self
1028     }
1029 }
1030 pub const DEVICE_DSM_FLAG_ALLOCATION_CONSOLIDATEABLE_ONLY: u32 = 1073741824u32;
1031 pub const DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE: u32 = 1u32;
1032 pub const DEVICE_DSM_FLAG_PHYSICAL_ADDRESSES_OMIT_TOTAL_RANGES: u32 = 268435456u32;
1033 pub const DEVICE_DSM_FLAG_REPAIR_INPUT_TOPOLOGY_ID_PRESENT: u32 = 1073741824u32;
1034 pub const DEVICE_DSM_FLAG_REPAIR_OUTPUT_PARITY_EXTENT: u32 = 536870912u32;
1035 pub const DEVICE_DSM_FLAG_SCRUB_OUTPUT_PARITY_EXTENT: u32 = 536870912u32;
1036 pub const DEVICE_DSM_FLAG_SCRUB_SKIP_IN_SYNC: u32 = 268435456u32;
1037 pub const DEVICE_DSM_FLAG_TRIM_BYPASS_RZAT: u32 = 1073741824u32;
1038 pub const DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED: u32 = 2147483648u32;
1039 #[repr(C)]
1040 pub struct DEVICE_DSM_FREE_SPACE_OUTPUT {
1041     pub Version: u32,
1042     pub FreeSpace: u64,
1043 }
1044 impl ::core::marker::Copy for DEVICE_DSM_FREE_SPACE_OUTPUT {}
1045 impl ::core::clone::Clone for DEVICE_DSM_FREE_SPACE_OUTPUT {
1046     fn clone(&self) -> Self {
1047         *self
1048     }
1049 }
1050 #[repr(C)]
1051 pub struct DEVICE_DSM_LOST_QUERY_OUTPUT {
1052     pub Version: u32,
1053     pub Size: u32,
1054     pub Alignment: u64,
1055     pub NumberOfBits: u32,
1056     pub BitMap: [u32; 1],
1057 }
1058 impl ::core::marker::Copy for DEVICE_DSM_LOST_QUERY_OUTPUT {}
1059 impl ::core::clone::Clone for DEVICE_DSM_LOST_QUERY_OUTPUT {
1060     fn clone(&self) -> Self {
1061         *self
1062     }
1063 }
1064 #[repr(C)]
1065 pub struct DEVICE_DSM_LOST_QUERY_PARAMETERS {
1066     pub Version: u32,
1067     pub Granularity: u64,
1068 }
1069 impl ::core::marker::Copy for DEVICE_DSM_LOST_QUERY_PARAMETERS {}
1070 impl ::core::clone::Clone for DEVICE_DSM_LOST_QUERY_PARAMETERS {
1071     fn clone(&self) -> Self {
1072         *self
1073     }
1074 }
1075 #[repr(C)]
1076 pub struct DEVICE_DSM_NOTIFICATION_PARAMETERS {
1077     pub Size: u32,
1078     pub Flags: u32,
1079     pub NumFileTypeIDs: u32,
1080     pub FileTypeID: [::windows_sys::core::GUID; 1],
1081 }
1082 impl ::core::marker::Copy for DEVICE_DSM_NOTIFICATION_PARAMETERS {}
1083 impl ::core::clone::Clone for DEVICE_DSM_NOTIFICATION_PARAMETERS {
1084     fn clone(&self) -> Self {
1085         *self
1086     }
1087 }
1088 pub const DEVICE_DSM_NOTIFY_FLAG_BEGIN: u32 = 1u32;
1089 pub const DEVICE_DSM_NOTIFY_FLAG_END: u32 = 2u32;
1090 #[repr(C)]
1091 pub struct DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS {
1092     pub Size: u32,
1093     pub TargetPriority: u8,
1094     pub Reserved: [u8; 3],
1095 }
1096 impl ::core::marker::Copy for DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS {}
1097 impl ::core::clone::Clone for DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS {
1098     fn clone(&self) -> Self {
1099         *self
1100     }
1101 }
1102 #[repr(C)]
1103 pub struct DEVICE_DSM_OFFLOAD_READ_PARAMETERS {
1104     pub Flags: u32,
1105     pub TimeToLive: u32,
1106     pub Reserved: [u32; 2],
1107 }
1108 impl ::core::marker::Copy for DEVICE_DSM_OFFLOAD_READ_PARAMETERS {}
1109 impl ::core::clone::Clone for DEVICE_DSM_OFFLOAD_READ_PARAMETERS {
1110     fn clone(&self) -> Self {
1111         *self
1112     }
1113 }
1114 #[repr(C)]
1115 pub struct DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS {
1116     pub Flags: u32,
1117     pub Reserved: u32,
1118     pub TokenOffset: u64,
1119     pub Token: STORAGE_OFFLOAD_TOKEN,
1120 }
1121 impl ::core::marker::Copy for DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS {}
1122 impl ::core::clone::Clone for DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS {
1123     fn clone(&self) -> Self {
1124         *self
1125     }
1126 }
1127 pub const DEVICE_DSM_PARAMETERS_V1: u32 = 1u32;
1128 #[repr(C)]
1129 pub struct DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT {
1130     pub Version: u32,
1131     pub Flags: u32,
1132     pub TotalNumberOfRanges: u32,
1133     pub NumberOfRangesReturned: u32,
1134     pub Ranges: [DEVICE_STORAGE_ADDRESS_RANGE; 1],
1135 }
1136 impl ::core::marker::Copy for DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT {}
1137 impl ::core::clone::Clone for DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT {
1138     fn clone(&self) -> Self {
1139         *self
1140     }
1141 }
1142 pub const DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT_V1: u32 = 1u32;
1143 pub const DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT_VERSION_V1: u32 = 1u32;
1144 #[repr(C)]
1145 pub struct DEVICE_DSM_RANGE_ERROR_INFO {
1146     pub Version: u32,
1147     pub Flags: u32,
1148     pub TotalNumberOfRanges: u32,
1149     pub NumberOfRangesReturned: u32,
1150     pub Ranges: [DEVICE_STORAGE_RANGE_ATTRIBUTES; 1],
1151 }
1152 impl ::core::marker::Copy for DEVICE_DSM_RANGE_ERROR_INFO {}
1153 impl ::core::clone::Clone for DEVICE_DSM_RANGE_ERROR_INFO {
1154     fn clone(&self) -> Self {
1155         *self
1156     }
1157 }
1158 pub const DEVICE_DSM_RANGE_ERROR_INFO_VERSION_V1: u32 = 1u32;
1159 pub const DEVICE_DSM_RANGE_ERROR_OUTPUT_V1: u32 = 1u32;
1160 #[repr(C)]
1161 #[cfg(feature = "Win32_Foundation")]
1162 pub struct DEVICE_DSM_REPORT_ZONES_DATA {
1163     pub Size: u32,
1164     pub ZoneCount: u32,
1165     pub Attributes: STORAGE_ZONES_ATTRIBUTES,
1166     pub Reserved0: u32,
1167     pub ZoneDescriptors: [STORAGE_ZONE_DESCRIPTOR; 1],
1168 }
1169 #[cfg(feature = "Win32_Foundation")]
1170 impl ::core::marker::Copy for DEVICE_DSM_REPORT_ZONES_DATA {}
1171 #[cfg(feature = "Win32_Foundation")]
1172 impl ::core::clone::Clone for DEVICE_DSM_REPORT_ZONES_DATA {
1173     fn clone(&self) -> Self {
1174         *self
1175     }
1176 }
1177 #[repr(C)]
1178 pub struct DEVICE_DSM_REPORT_ZONES_PARAMETERS {
1179     pub Size: u32,
1180     pub ReportOption: u8,
1181     pub Partial: u8,
1182     pub Reserved: [u8; 2],
1183 }
1184 impl ::core::marker::Copy for DEVICE_DSM_REPORT_ZONES_PARAMETERS {}
1185 impl ::core::clone::Clone for DEVICE_DSM_REPORT_ZONES_PARAMETERS {
1186     fn clone(&self) -> Self {
1187         *self
1188     }
1189 }
1190 #[repr(C)]
1191 pub struct DEVICE_DSM_TIERING_QUERY_INPUT {
1192     pub Version: u32,
1193     pub Size: u32,
1194     pub Flags: u32,
1195     pub NumberOfTierIds: u32,
1196     pub TierIds: [::windows_sys::core::GUID; 1],
1197 }
1198 impl ::core::marker::Copy for DEVICE_DSM_TIERING_QUERY_INPUT {}
1199 impl ::core::clone::Clone for DEVICE_DSM_TIERING_QUERY_INPUT {
1200     fn clone(&self) -> Self {
1201         *self
1202     }
1203 }
1204 #[repr(C)]
1205 pub struct DEVICE_DSM_TIERING_QUERY_OUTPUT {
1206     pub Version: u32,
1207     pub Size: u32,
1208     pub Flags: u32,
1209     pub Reserved: u32,
1210     pub Alignment: u64,
1211     pub TotalNumberOfRegions: u32,
1212     pub NumberOfRegionsReturned: u32,
1213     pub Regions: [STORAGE_TIER_REGION; 1],
1214 }
1215 impl ::core::marker::Copy for DEVICE_DSM_TIERING_QUERY_OUTPUT {}
1216 impl ::core::clone::Clone for DEVICE_DSM_TIERING_QUERY_OUTPUT {
1217     fn clone(&self) -> Self {
1218         *self
1219     }
1220 }
1221 #[repr(C)]
1222 pub struct DEVICE_INTERNAL_STATUS_DATA {
1223     pub Version: u32,
1224     pub Size: u32,
1225     pub T10VendorId: u64,
1226     pub DataSet1Length: u32,
1227     pub DataSet2Length: u32,
1228     pub DataSet3Length: u32,
1229     pub DataSet4Length: u32,
1230     pub StatusDataVersion: u8,
1231     pub Reserved: [u8; 3],
1232     pub ReasonIdentifier: [u8; 128],
1233     pub StatusDataLength: u32,
1234     pub StatusData: [u8; 1],
1235 }
1236 impl ::core::marker::Copy for DEVICE_INTERNAL_STATUS_DATA {}
1237 impl ::core::clone::Clone for DEVICE_INTERNAL_STATUS_DATA {
1238     fn clone(&self) -> Self {
1239         *self
1240     }
1241 }
1242 pub type DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = i32;
1243 pub const DeviceInternalStatusDataRequestTypeUndefined: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = 0i32;
1244 pub const DeviceCurrentInternalStatusDataHeader: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = 1i32;
1245 pub const DeviceCurrentInternalStatusData: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = 2i32;
1246 pub const DeviceSavedInternalStatusDataHeader: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = 3i32;
1247 pub const DeviceSavedInternalStatusData: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE = 4i32;
1248 pub type DEVICE_INTERNAL_STATUS_DATA_SET = i32;
1249 pub const DeviceStatusDataSetUndefined: DEVICE_INTERNAL_STATUS_DATA_SET = 0i32;
1250 pub const DeviceStatusDataSet1: DEVICE_INTERNAL_STATUS_DATA_SET = 1i32;
1251 pub const DeviceStatusDataSet2: DEVICE_INTERNAL_STATUS_DATA_SET = 2i32;
1252 pub const DeviceStatusDataSet3: DEVICE_INTERNAL_STATUS_DATA_SET = 3i32;
1253 pub const DeviceStatusDataSet4: DEVICE_INTERNAL_STATUS_DATA_SET = 4i32;
1254 pub const DeviceStatusDataSetMax: DEVICE_INTERNAL_STATUS_DATA_SET = 5i32;
1255 #[repr(C)]
1256 pub struct DEVICE_LB_PROVISIONING_DESCRIPTOR {
1257     pub Version: u32,
1258     pub Size: u32,
1259     pub _bitfield: u8,
1260     pub Reserved1: [u8; 7],
1261     pub OptimalUnmapGranularity: u64,
1262     pub UnmapGranularityAlignment: u64,
1263     pub MaxUnmapLbaCount: u32,
1264     pub MaxUnmapBlockDescriptorCount: u32,
1265 }
1266 impl ::core::marker::Copy for DEVICE_LB_PROVISIONING_DESCRIPTOR {}
1267 impl ::core::clone::Clone for DEVICE_LB_PROVISIONING_DESCRIPTOR {
1268     fn clone(&self) -> Self {
1269         *self
1270     }
1271 }
1272 #[repr(C)]
1273 pub struct DEVICE_LOCATION {
1274     pub Socket: u32,
1275     pub Slot: u32,
1276     pub Adapter: u32,
1277     pub Port: u32,
1278     pub Anonymous: DEVICE_LOCATION_0,
1279 }
1280 impl ::core::marker::Copy for DEVICE_LOCATION {}
1281 impl ::core::clone::Clone for DEVICE_LOCATION {
1282     fn clone(&self) -> Self {
1283         *self
1284     }
1285 }
1286 #[repr(C)]
1287 pub union DEVICE_LOCATION_0 {
1288     pub Anonymous1: DEVICE_LOCATION_0_0,
1289     pub Anonymous2: DEVICE_LOCATION_0_1,
1290 }
1291 impl ::core::marker::Copy for DEVICE_LOCATION_0 {}
1292 impl ::core::clone::Clone for DEVICE_LOCATION_0 {
1293     fn clone(&self) -> Self {
1294         *self
1295     }
1296 }
1297 #[repr(C)]
1298 pub struct DEVICE_LOCATION_0_0 {
1299     pub Channel: u32,
1300     pub Device: u32,
1301 }
1302 impl ::core::marker::Copy for DEVICE_LOCATION_0_0 {}
1303 impl ::core::clone::Clone for DEVICE_LOCATION_0_0 {
1304     fn clone(&self) -> Self {
1305         *self
1306     }
1307 }
1308 #[repr(C)]
1309 pub struct DEVICE_LOCATION_0_1 {
1310     pub Target: u32,
1311     pub Lun: u32,
1312 }
1313 impl ::core::marker::Copy for DEVICE_LOCATION_0_1 {}
1314 impl ::core::clone::Clone for DEVICE_LOCATION_0_1 {
1315     fn clone(&self) -> Self {
1316         *self
1317     }
1318 }
1319 #[repr(C)]
1320 pub struct DEVICE_MANAGE_DATA_SET_ATTRIBUTES {
1321     pub Size: u32,
1322     pub Action: u32,
1323     pub Flags: u32,
1324     pub ParameterBlockOffset: u32,
1325     pub ParameterBlockLength: u32,
1326     pub DataSetRangesOffset: u32,
1327     pub DataSetRangesLength: u32,
1328 }
1329 impl ::core::marker::Copy for DEVICE_MANAGE_DATA_SET_ATTRIBUTES {}
1330 impl ::core::clone::Clone for DEVICE_MANAGE_DATA_SET_ATTRIBUTES {
1331     fn clone(&self) -> Self {
1332         *self
1333     }
1334 }
1335 #[repr(C)]
1336 pub struct DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT {
1337     pub Size: u32,
1338     pub Action: u32,
1339     pub Flags: u32,
1340     pub OperationStatus: u32,
1341     pub ExtendedError: u32,
1342     pub TargetDetailedError: u32,
1343     pub ReservedStatus: u32,
1344     pub OutputBlockOffset: u32,
1345     pub OutputBlockLength: u32,
1346 }
1347 impl ::core::marker::Copy for DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT {}
1348 impl ::core::clone::Clone for DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT {
1349     fn clone(&self) -> Self {
1350         *self
1351     }
1352 }
1353 #[repr(C)]
1354 #[cfg(feature = "Win32_Storage_FileSystem")]
1355 pub struct DEVICE_MEDIA_INFO {
1356     pub DeviceSpecific: DEVICE_MEDIA_INFO_0,
1357 }
1358 #[cfg(feature = "Win32_Storage_FileSystem")]
1359 impl ::core::marker::Copy for DEVICE_MEDIA_INFO {}
1360 #[cfg(feature = "Win32_Storage_FileSystem")]
1361 impl ::core::clone::Clone for DEVICE_MEDIA_INFO {
1362     fn clone(&self) -> Self {
1363         *self
1364     }
1365 }
1366 #[repr(C)]
1367 #[cfg(feature = "Win32_Storage_FileSystem")]
1368 pub union DEVICE_MEDIA_INFO_0 {
1369     pub DiskInfo: DEVICE_MEDIA_INFO_0_0,
1370     pub RemovableDiskInfo: DEVICE_MEDIA_INFO_0_1,
1371     pub TapeInfo: DEVICE_MEDIA_INFO_0_2,
1372 }
1373 #[cfg(feature = "Win32_Storage_FileSystem")]
1374 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0 {}
1375 #[cfg(feature = "Win32_Storage_FileSystem")]
1376 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0 {
1377     fn clone(&self) -> Self {
1378         *self
1379     }
1380 }
1381 #[repr(C)]
1382 #[cfg(feature = "Win32_Storage_FileSystem")]
1383 pub struct DEVICE_MEDIA_INFO_0_0 {
1384     pub Cylinders: i64,
1385     pub MediaType: STORAGE_MEDIA_TYPE,
1386     pub TracksPerCylinder: u32,
1387     pub SectorsPerTrack: u32,
1388     pub BytesPerSector: u32,
1389     pub NumberMediaSides: u32,
1390     pub MediaCharacteristics: u32,
1391 }
1392 #[cfg(feature = "Win32_Storage_FileSystem")]
1393 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0_0 {}
1394 #[cfg(feature = "Win32_Storage_FileSystem")]
1395 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0_0 {
1396     fn clone(&self) -> Self {
1397         *self
1398     }
1399 }
1400 #[repr(C)]
1401 #[cfg(feature = "Win32_Storage_FileSystem")]
1402 pub struct DEVICE_MEDIA_INFO_0_1 {
1403     pub Cylinders: i64,
1404     pub MediaType: STORAGE_MEDIA_TYPE,
1405     pub TracksPerCylinder: u32,
1406     pub SectorsPerTrack: u32,
1407     pub BytesPerSector: u32,
1408     pub NumberMediaSides: u32,
1409     pub MediaCharacteristics: u32,
1410 }
1411 #[cfg(feature = "Win32_Storage_FileSystem")]
1412 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0_1 {}
1413 #[cfg(feature = "Win32_Storage_FileSystem")]
1414 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0_1 {
1415     fn clone(&self) -> Self {
1416         *self
1417     }
1418 }
1419 #[repr(C)]
1420 #[cfg(feature = "Win32_Storage_FileSystem")]
1421 pub struct DEVICE_MEDIA_INFO_0_2 {
1422     pub MediaType: STORAGE_MEDIA_TYPE,
1423     pub MediaCharacteristics: u32,
1424     pub CurrentBlockSize: u32,
1425     pub BusType: super::super::Storage::FileSystem::STORAGE_BUS_TYPE,
1426     pub BusSpecificData: DEVICE_MEDIA_INFO_0_2_0,
1427 }
1428 #[cfg(feature = "Win32_Storage_FileSystem")]
1429 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0_2 {}
1430 #[cfg(feature = "Win32_Storage_FileSystem")]
1431 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0_2 {
1432     fn clone(&self) -> Self {
1433         *self
1434     }
1435 }
1436 #[repr(C)]
1437 #[cfg(feature = "Win32_Storage_FileSystem")]
1438 pub union DEVICE_MEDIA_INFO_0_2_0 {
1439     pub ScsiInformation: DEVICE_MEDIA_INFO_0_2_0_0,
1440 }
1441 #[cfg(feature = "Win32_Storage_FileSystem")]
1442 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0_2_0 {}
1443 #[cfg(feature = "Win32_Storage_FileSystem")]
1444 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0_2_0 {
1445     fn clone(&self) -> Self {
1446         *self
1447     }
1448 }
1449 #[repr(C)]
1450 #[cfg(feature = "Win32_Storage_FileSystem")]
1451 pub struct DEVICE_MEDIA_INFO_0_2_0_0 {
1452     pub MediumType: u8,
1453     pub DensityCode: u8,
1454 }
1455 #[cfg(feature = "Win32_Storage_FileSystem")]
1456 impl ::core::marker::Copy for DEVICE_MEDIA_INFO_0_2_0_0 {}
1457 #[cfg(feature = "Win32_Storage_FileSystem")]
1458 impl ::core::clone::Clone for DEVICE_MEDIA_INFO_0_2_0_0 {
1459     fn clone(&self) -> Self {
1460         *self
1461     }
1462 }
1463 #[repr(C)]
1464 #[cfg(feature = "Win32_Foundation")]
1465 pub struct DEVICE_POWER_DESCRIPTOR {
1466     pub Version: u32,
1467     pub Size: u32,
1468     pub DeviceAttentionSupported: super::super::Foundation::BOOLEAN,
1469     pub AsynchronousNotificationSupported: super::super::Foundation::BOOLEAN,
1470     pub IdlePowerManagementEnabled: super::super::Foundation::BOOLEAN,
1471     pub D3ColdEnabled: super::super::Foundation::BOOLEAN,
1472     pub D3ColdSupported: super::super::Foundation::BOOLEAN,
1473     pub NoVerifyDuringIdlePower: super::super::Foundation::BOOLEAN,
1474     pub Reserved: [u8; 2],
1475     pub IdleTimeoutInMS: u32,
1476 }
1477 #[cfg(feature = "Win32_Foundation")]
1478 impl ::core::marker::Copy for DEVICE_POWER_DESCRIPTOR {}
1479 #[cfg(feature = "Win32_Foundation")]
1480 impl ::core::clone::Clone for DEVICE_POWER_DESCRIPTOR {
1481     fn clone(&self) -> Self {
1482         *self
1483     }
1484 }
1485 #[repr(C)]
1486 #[cfg(feature = "Win32_Foundation")]
1487 pub struct DEVICE_SEEK_PENALTY_DESCRIPTOR {
1488     pub Version: u32,
1489     pub Size: u32,
1490     pub IncursSeekPenalty: super::super::Foundation::BOOLEAN,
1491 }
1492 #[cfg(feature = "Win32_Foundation")]
1493 impl ::core::marker::Copy for DEVICE_SEEK_PENALTY_DESCRIPTOR {}
1494 #[cfg(feature = "Win32_Foundation")]
1495 impl ::core::clone::Clone for DEVICE_SEEK_PENALTY_DESCRIPTOR {
1496     fn clone(&self) -> Self {
1497         *self
1498     }
1499 }
1500 #[repr(C)]
1501 pub struct DEVICE_STORAGE_ADDRESS_RANGE {
1502     pub StartAddress: i64,
1503     pub LengthInBytes: u64,
1504 }
1505 impl ::core::marker::Copy for DEVICE_STORAGE_ADDRESS_RANGE {}
1506 impl ::core::clone::Clone for DEVICE_STORAGE_ADDRESS_RANGE {
1507     fn clone(&self) -> Self {
1508         *self
1509     }
1510 }
1511 pub const DEVICE_STORAGE_NO_ERRORS: u32 = 1u32;
1512 #[repr(C)]
1513 pub struct DEVICE_STORAGE_RANGE_ATTRIBUTES {
1514     pub LengthInBytes: u64,
1515     pub Anonymous: DEVICE_STORAGE_RANGE_ATTRIBUTES_0,
1516     pub Reserved: u32,
1517 }
1518 impl ::core::marker::Copy for DEVICE_STORAGE_RANGE_ATTRIBUTES {}
1519 impl ::core::clone::Clone for DEVICE_STORAGE_RANGE_ATTRIBUTES {
1520     fn clone(&self) -> Self {
1521         *self
1522     }
1523 }
1524 #[repr(C)]
1525 pub union DEVICE_STORAGE_RANGE_ATTRIBUTES_0 {
1526     pub AllFlags: u32,
1527     pub Anonymous: DEVICE_STORAGE_RANGE_ATTRIBUTES_0_0,
1528 }
1529 impl ::core::marker::Copy for DEVICE_STORAGE_RANGE_ATTRIBUTES_0 {}
1530 impl ::core::clone::Clone for DEVICE_STORAGE_RANGE_ATTRIBUTES_0 {
1531     fn clone(&self) -> Self {
1532         *self
1533     }
1534 }
1535 #[repr(C)]
1536 pub struct DEVICE_STORAGE_RANGE_ATTRIBUTES_0_0 {
1537     pub _bitfield: u32,
1538 }
1539 impl ::core::marker::Copy for DEVICE_STORAGE_RANGE_ATTRIBUTES_0_0 {}
1540 impl ::core::clone::Clone for DEVICE_STORAGE_RANGE_ATTRIBUTES_0_0 {
1541     fn clone(&self) -> Self {
1542         *self
1543     }
1544 }
1545 #[repr(C)]
1546 #[cfg(feature = "Win32_Foundation")]
1547 pub struct DEVICE_TRIM_DESCRIPTOR {
1548     pub Version: u32,
1549     pub Size: u32,
1550     pub TrimEnabled: super::super::Foundation::BOOLEAN,
1551 }
1552 #[cfg(feature = "Win32_Foundation")]
1553 impl ::core::marker::Copy for DEVICE_TRIM_DESCRIPTOR {}
1554 #[cfg(feature = "Win32_Foundation")]
1555 impl ::core::clone::Clone for DEVICE_TRIM_DESCRIPTOR {
1556     fn clone(&self) -> Self {
1557         *self
1558     }
1559 }
1560 #[repr(C)]
1561 #[cfg(feature = "Win32_Foundation")]
1562 pub struct DEVICE_WRITE_AGGREGATION_DESCRIPTOR {
1563     pub Version: u32,
1564     pub Size: u32,
1565     pub BenefitsFromWriteAggregation: super::super::Foundation::BOOLEAN,
1566 }
1567 #[cfg(feature = "Win32_Foundation")]
1568 impl ::core::marker::Copy for DEVICE_WRITE_AGGREGATION_DESCRIPTOR {}
1569 #[cfg(feature = "Win32_Foundation")]
1570 impl ::core::clone::Clone for DEVICE_WRITE_AGGREGATION_DESCRIPTOR {
1571     fn clone(&self) -> Self {
1572         *self
1573     }
1574 }
1575 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1576 pub const DEVPKEY_Storage_Disk_Number: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1577     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1578     pid: 5u32,
1579 };
1580 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1581 pub const DEVPKEY_Storage_Gpt_Name: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1582     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1583     pid: 9u32,
1584 };
1585 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1586 pub const DEVPKEY_Storage_Gpt_Type: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1587     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1588     pid: 8u32,
1589 };
1590 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1591 pub const DEVPKEY_Storage_Mbr_Type: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1592     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1593     pid: 7u32,
1594 };
1595 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1596 pub const DEVPKEY_Storage_Partition_Number: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1597     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1598     pid: 6u32,
1599 };
1600 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1601 pub const DEVPKEY_Storage_Portable: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1602     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1603     pid: 2u32,
1604 };
1605 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1606 pub const DEVPKEY_Storage_Removable_Media: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1607     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1608     pid: 3u32,
1609 };
1610 #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")]
1611 pub const DEVPKEY_Storage_System_Critical: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY = super::super::UI::Shell::PropertiesSystem::PROPERTYKEY {
1612     fmtid: ::windows_sys::core::GUID { data1: 1293860584, data2: 2051, data3: 18292, data4: [152, 66, 183, 125, 181, 2, 101, 233] },
1613     pid: 4u32,
1614 };
1615 pub const DISABLE_SMART: u32 = 217u32;
1616 pub const DISK_ATTRIBUTE_OFFLINE: u64 = 1u64;
1617 pub const DISK_ATTRIBUTE_READ_ONLY: u64 = 2u64;
1618 pub const DISK_BINNING: u32 = 3u32;
1619 #[repr(C)]
1620 #[cfg(feature = "Win32_Foundation")]
1621 pub struct DISK_CACHE_INFORMATION {
1622     pub ParametersSavable: super::super::Foundation::BOOLEAN,
1623     pub ReadCacheEnabled: super::super::Foundation::BOOLEAN,
1624     pub WriteCacheEnabled: super::super::Foundation::BOOLEAN,
1625     pub ReadRetentionPriority: DISK_CACHE_RETENTION_PRIORITY,
1626     pub WriteRetentionPriority: DISK_CACHE_RETENTION_PRIORITY,
1627     pub DisablePrefetchTransferLength: u16,
1628     pub PrefetchScalar: super::super::Foundation::BOOLEAN,
1629     pub Anonymous: DISK_CACHE_INFORMATION_0,
1630 }
1631 #[cfg(feature = "Win32_Foundation")]
1632 impl ::core::marker::Copy for DISK_CACHE_INFORMATION {}
1633 #[cfg(feature = "Win32_Foundation")]
1634 impl ::core::clone::Clone for DISK_CACHE_INFORMATION {
1635     fn clone(&self) -> Self {
1636         *self
1637     }
1638 }
1639 #[repr(C)]
1640 #[cfg(feature = "Win32_Foundation")]
1641 pub union DISK_CACHE_INFORMATION_0 {
1642     pub ScalarPrefetch: DISK_CACHE_INFORMATION_0_1,
1643     pub BlockPrefetch: DISK_CACHE_INFORMATION_0_0,
1644 }
1645 #[cfg(feature = "Win32_Foundation")]
1646 impl ::core::marker::Copy for DISK_CACHE_INFORMATION_0 {}
1647 #[cfg(feature = "Win32_Foundation")]
1648 impl ::core::clone::Clone for DISK_CACHE_INFORMATION_0 {
1649     fn clone(&self) -> Self {
1650         *self
1651     }
1652 }
1653 #[repr(C)]
1654 #[cfg(feature = "Win32_Foundation")]
1655 pub struct DISK_CACHE_INFORMATION_0_0 {
1656     pub Minimum: u16,
1657     pub Maximum: u16,
1658 }
1659 #[cfg(feature = "Win32_Foundation")]
1660 impl ::core::marker::Copy for DISK_CACHE_INFORMATION_0_0 {}
1661 #[cfg(feature = "Win32_Foundation")]
1662 impl ::core::clone::Clone for DISK_CACHE_INFORMATION_0_0 {
1663     fn clone(&self) -> Self {
1664         *self
1665     }
1666 }
1667 #[repr(C)]
1668 #[cfg(feature = "Win32_Foundation")]
1669 pub struct DISK_CACHE_INFORMATION_0_1 {
1670     pub Minimum: u16,
1671     pub Maximum: u16,
1672     pub MaximumBlocks: u16,
1673 }
1674 #[cfg(feature = "Win32_Foundation")]
1675 impl ::core::marker::Copy for DISK_CACHE_INFORMATION_0_1 {}
1676 #[cfg(feature = "Win32_Foundation")]
1677 impl ::core::clone::Clone for DISK_CACHE_INFORMATION_0_1 {
1678     fn clone(&self) -> Self {
1679         *self
1680     }
1681 }
1682 pub type DISK_CACHE_RETENTION_PRIORITY = i32;
1683 pub const EqualPriority: DISK_CACHE_RETENTION_PRIORITY = 0i32;
1684 pub const KeepPrefetchedData: DISK_CACHE_RETENTION_PRIORITY = 1i32;
1685 pub const KeepReadData: DISK_CACHE_RETENTION_PRIORITY = 2i32;
1686 #[repr(C)]
1687 pub struct DISK_CONTROLLER_NUMBER {
1688     pub ControllerNumber: u32,
1689     pub DiskNumber: u32,
1690 }
1691 impl ::core::marker::Copy for DISK_CONTROLLER_NUMBER {}
1692 impl ::core::clone::Clone for DISK_CONTROLLER_NUMBER {
1693     fn clone(&self) -> Self {
1694         *self
1695     }
1696 }
1697 #[repr(C)]
1698 pub struct DISK_DETECTION_INFO {
1699     pub SizeOfDetectInfo: u32,
1700     pub DetectionType: DETECTION_TYPE,
1701     pub Anonymous: DISK_DETECTION_INFO_0,
1702 }
1703 impl ::core::marker::Copy for DISK_DETECTION_INFO {}
1704 impl ::core::clone::Clone for DISK_DETECTION_INFO {
1705     fn clone(&self) -> Self {
1706         *self
1707     }
1708 }
1709 #[repr(C)]
1710 pub union DISK_DETECTION_INFO_0 {
1711     pub Anonymous: DISK_DETECTION_INFO_0_0,
1712 }
1713 impl ::core::marker::Copy for DISK_DETECTION_INFO_0 {}
1714 impl ::core::clone::Clone for DISK_DETECTION_INFO_0 {
1715     fn clone(&self) -> Self {
1716         *self
1717     }
1718 }
1719 #[repr(C)]
1720 pub struct DISK_DETECTION_INFO_0_0 {
1721     pub Int13: DISK_INT13_INFO,
1722     pub ExInt13: DISK_EX_INT13_INFO,
1723 }
1724 impl ::core::marker::Copy for DISK_DETECTION_INFO_0_0 {}
1725 impl ::core::clone::Clone for DISK_DETECTION_INFO_0_0 {
1726     fn clone(&self) -> Self {
1727         *self
1728     }
1729 }
1730 #[repr(C)]
1731 pub struct DISK_EXTENT {
1732     pub DiskNumber: u32,
1733     pub StartingOffset: i64,
1734     pub ExtentLength: i64,
1735 }
1736 impl ::core::marker::Copy for DISK_EXTENT {}
1737 impl ::core::clone::Clone for DISK_EXTENT {
1738     fn clone(&self) -> Self {
1739         *self
1740     }
1741 }
1742 #[repr(C)]
1743 pub struct DISK_EX_INT13_INFO {
1744     pub ExBufferSize: u16,
1745     pub ExFlags: u16,
1746     pub ExCylinders: u32,
1747     pub ExHeads: u32,
1748     pub ExSectorsPerTrack: u32,
1749     pub ExSectorsPerDrive: u64,
1750     pub ExSectorSize: u16,
1751     pub ExReserved: u16,
1752 }
1753 impl ::core::marker::Copy for DISK_EX_INT13_INFO {}
1754 impl ::core::clone::Clone for DISK_EX_INT13_INFO {
1755     fn clone(&self) -> Self {
1756         *self
1757     }
1758 }
1759 #[repr(C)]
1760 pub struct DISK_GEOMETRY {
1761     pub Cylinders: i64,
1762     pub MediaType: MEDIA_TYPE,
1763     pub TracksPerCylinder: u32,
1764     pub SectorsPerTrack: u32,
1765     pub BytesPerSector: u32,
1766 }
1767 impl ::core::marker::Copy for DISK_GEOMETRY {}
1768 impl ::core::clone::Clone for DISK_GEOMETRY {
1769     fn clone(&self) -> Self {
1770         *self
1771     }
1772 }
1773 #[repr(C)]
1774 pub struct DISK_GEOMETRY_EX {
1775     pub Geometry: DISK_GEOMETRY,
1776     pub DiskSize: i64,
1777     pub Data: [u8; 1],
1778 }
1779 impl ::core::marker::Copy for DISK_GEOMETRY_EX {}
1780 impl ::core::clone::Clone for DISK_GEOMETRY_EX {
1781     fn clone(&self) -> Self {
1782         *self
1783     }
1784 }
1785 #[repr(C)]
1786 pub struct DISK_GROW_PARTITION {
1787     pub PartitionNumber: u32,
1788     pub BytesToGrow: i64,
1789 }
1790 impl ::core::marker::Copy for DISK_GROW_PARTITION {}
1791 impl ::core::clone::Clone for DISK_GROW_PARTITION {
1792     fn clone(&self) -> Self {
1793         *self
1794     }
1795 }
1796 #[repr(C)]
1797 pub struct DISK_HISTOGRAM {
1798     pub DiskSize: i64,
1799     pub Start: i64,
1800     pub End: i64,
1801     pub Average: i64,
1802     pub AverageRead: i64,
1803     pub AverageWrite: i64,
1804     pub Granularity: u32,
1805     pub Size: u32,
1806     pub ReadCount: u32,
1807     pub WriteCount: u32,
1808     pub Histogram: *mut HISTOGRAM_BUCKET,
1809 }
1810 impl ::core::marker::Copy for DISK_HISTOGRAM {}
1811 impl ::core::clone::Clone for DISK_HISTOGRAM {
1812     fn clone(&self) -> Self {
1813         *self
1814     }
1815 }
1816 #[repr(C)]
1817 pub struct DISK_INT13_INFO {
1818     pub DriveSelect: u16,
1819     pub MaxCylinders: u32,
1820     pub SectorsPerTrack: u16,
1821     pub MaxHeads: u16,
1822     pub NumberDrives: u16,
1823 }
1824 impl ::core::marker::Copy for DISK_INT13_INFO {}
1825 impl ::core::clone::Clone for DISK_INT13_INFO {
1826     fn clone(&self) -> Self {
1827         *self
1828     }
1829 }
1830 #[repr(C)]
1831 pub struct DISK_LOGGING {
1832     pub Function: u8,
1833     pub BufferAddress: *mut ::core::ffi::c_void,
1834     pub BufferSize: u32,
1835 }
1836 impl ::core::marker::Copy for DISK_LOGGING {}
1837 impl ::core::clone::Clone for DISK_LOGGING {
1838     fn clone(&self) -> Self {
1839         *self
1840     }
1841 }
1842 pub const DISK_LOGGING_DUMP: u32 = 2u32;
1843 pub const DISK_LOGGING_START: u32 = 0u32;
1844 pub const DISK_LOGGING_STOP: u32 = 1u32;
1845 #[repr(C)]
1846 pub struct DISK_PARTITION_INFO {
1847     pub SizeOfPartitionInfo: u32,
1848     pub PartitionStyle: PARTITION_STYLE,
1849     pub Anonymous: DISK_PARTITION_INFO_0,
1850 }
1851 impl ::core::marker::Copy for DISK_PARTITION_INFO {}
1852 impl ::core::clone::Clone for DISK_PARTITION_INFO {
1853     fn clone(&self) -> Self {
1854         *self
1855     }
1856 }
1857 #[repr(C)]
1858 pub union DISK_PARTITION_INFO_0 {
1859     pub Mbr: DISK_PARTITION_INFO_0_1,
1860     pub Gpt: DISK_PARTITION_INFO_0_0,
1861 }
1862 impl ::core::marker::Copy for DISK_PARTITION_INFO_0 {}
1863 impl ::core::clone::Clone for DISK_PARTITION_INFO_0 {
1864     fn clone(&self) -> Self {
1865         *self
1866     }
1867 }
1868 #[repr(C)]
1869 pub struct DISK_PARTITION_INFO_0_0 {
1870     pub DiskId: ::windows_sys::core::GUID,
1871 }
1872 impl ::core::marker::Copy for DISK_PARTITION_INFO_0_0 {}
1873 impl ::core::clone::Clone for DISK_PARTITION_INFO_0_0 {
1874     fn clone(&self) -> Self {
1875         *self
1876     }
1877 }
1878 #[repr(C)]
1879 pub struct DISK_PARTITION_INFO_0_1 {
1880     pub Signature: u32,
1881     pub CheckSum: u32,
1882 }
1883 impl ::core::marker::Copy for DISK_PARTITION_INFO_0_1 {}
1884 impl ::core::clone::Clone for DISK_PARTITION_INFO_0_1 {
1885     fn clone(&self) -> Self {
1886         *self
1887     }
1888 }
1889 #[repr(C)]
1890 pub struct DISK_PERFORMANCE {
1891     pub BytesRead: i64,
1892     pub BytesWritten: i64,
1893     pub ReadTime: i64,
1894     pub WriteTime: i64,
1895     pub IdleTime: i64,
1896     pub ReadCount: u32,
1897     pub WriteCount: u32,
1898     pub QueueDepth: u32,
1899     pub SplitCount: u32,
1900     pub QueryTime: i64,
1901     pub StorageDeviceNumber: u32,
1902     pub StorageManagerName: [u16; 8],
1903 }
1904 impl ::core::marker::Copy for DISK_PERFORMANCE {}
1905 impl ::core::clone::Clone for DISK_PERFORMANCE {
1906     fn clone(&self) -> Self {
1907         *self
1908     }
1909 }
1910 #[repr(C)]
1911 #[cfg(feature = "Win32_Foundation")]
1912 pub struct DISK_RECORD {
1913     pub ByteOffset: i64,
1914     pub StartTime: i64,
1915     pub EndTime: i64,
1916     pub VirtualAddress: *mut ::core::ffi::c_void,
1917     pub NumberOfBytes: u32,
1918     pub DeviceNumber: u8,
1919     pub ReadRequest: super::super::Foundation::BOOLEAN,
1920 }
1921 #[cfg(feature = "Win32_Foundation")]
1922 impl ::core::marker::Copy for DISK_RECORD {}
1923 #[cfg(feature = "Win32_Foundation")]
1924 impl ::core::clone::Clone for DISK_RECORD {
1925     fn clone(&self) -> Self {
1926         *self
1927     }
1928 }
1929 #[repr(C, packed(1))]
1930 pub struct DRIVERSTATUS {
1931     pub bDriverError: u8,
1932     pub bIDEError: u8,
1933     pub bReserved: [u8; 2],
1934     pub dwReserved: [u32; 2],
1935 }
1936 impl ::core::marker::Copy for DRIVERSTATUS {}
1937 impl ::core::clone::Clone for DRIVERSTATUS {
1938     fn clone(&self) -> Self {
1939         *self
1940     }
1941 }
1942 #[repr(C)]
1943 #[cfg(feature = "Win32_Foundation")]
1944 pub struct DRIVE_LAYOUT_INFORMATION {
1945     pub PartitionCount: u32,
1946     pub Signature: u32,
1947     pub PartitionEntry: [PARTITION_INFORMATION; 1],
1948 }
1949 #[cfg(feature = "Win32_Foundation")]
1950 impl ::core::marker::Copy for DRIVE_LAYOUT_INFORMATION {}
1951 #[cfg(feature = "Win32_Foundation")]
1952 impl ::core::clone::Clone for DRIVE_LAYOUT_INFORMATION {
1953     fn clone(&self) -> Self {
1954         *self
1955     }
1956 }
1957 #[repr(C)]
1958 #[cfg(feature = "Win32_Foundation")]
1959 pub struct DRIVE_LAYOUT_INFORMATION_EX {
1960     pub PartitionStyle: u32,
1961     pub PartitionCount: u32,
1962     pub Anonymous: DRIVE_LAYOUT_INFORMATION_EX_0,
1963     pub PartitionEntry: [PARTITION_INFORMATION_EX; 1],
1964 }
1965 #[cfg(feature = "Win32_Foundation")]
1966 impl ::core::marker::Copy for DRIVE_LAYOUT_INFORMATION_EX {}
1967 #[cfg(feature = "Win32_Foundation")]
1968 impl ::core::clone::Clone for DRIVE_LAYOUT_INFORMATION_EX {
1969     fn clone(&self) -> Self {
1970         *self
1971     }
1972 }
1973 #[repr(C)]
1974 #[cfg(feature = "Win32_Foundation")]
1975 pub union DRIVE_LAYOUT_INFORMATION_EX_0 {
1976     pub Mbr: DRIVE_LAYOUT_INFORMATION_MBR,
1977     pub Gpt: DRIVE_LAYOUT_INFORMATION_GPT,
1978 }
1979 #[cfg(feature = "Win32_Foundation")]
1980 impl ::core::marker::Copy for DRIVE_LAYOUT_INFORMATION_EX_0 {}
1981 #[cfg(feature = "Win32_Foundation")]
1982 impl ::core::clone::Clone for DRIVE_LAYOUT_INFORMATION_EX_0 {
1983     fn clone(&self) -> Self {
1984         *self
1985     }
1986 }
1987 #[repr(C)]
1988 pub struct DRIVE_LAYOUT_INFORMATION_GPT {
1989     pub DiskId: ::windows_sys::core::GUID,
1990     pub StartingUsableOffset: i64,
1991     pub UsableLength: i64,
1992     pub MaxPartitionCount: u32,
1993 }
1994 impl ::core::marker::Copy for DRIVE_LAYOUT_INFORMATION_GPT {}
1995 impl ::core::clone::Clone for DRIVE_LAYOUT_INFORMATION_GPT {
1996     fn clone(&self) -> Self {
1997         *self
1998     }
1999 }
2000 #[repr(C)]
2001 pub struct DRIVE_LAYOUT_INFORMATION_MBR {
2002     pub Signature: u32,
2003     pub CheckSum: u32,
2004 }
2005 impl ::core::marker::Copy for DRIVE_LAYOUT_INFORMATION_MBR {}
2006 impl ::core::clone::Clone for DRIVE_LAYOUT_INFORMATION_MBR {
2007     fn clone(&self) -> Self {
2008         *self
2009     }
2010 }
2011 #[repr(C)]
2012 #[cfg(feature = "Win32_Foundation")]
2013 pub struct DUPLICATE_EXTENTS_DATA {
2014     pub FileHandle: super::super::Foundation::HANDLE,
2015     pub SourceFileOffset: i64,
2016     pub TargetFileOffset: i64,
2017     pub ByteCount: i64,
2018 }
2019 #[cfg(feature = "Win32_Foundation")]
2020 impl ::core::marker::Copy for DUPLICATE_EXTENTS_DATA {}
2021 #[cfg(feature = "Win32_Foundation")]
2022 impl ::core::clone::Clone for DUPLICATE_EXTENTS_DATA {
2023     fn clone(&self) -> Self {
2024         *self
2025     }
2026 }
2027 #[repr(C)]
2028 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2029 pub struct DUPLICATE_EXTENTS_DATA32 {
2030     pub FileHandle: u32,
2031     pub SourceFileOffset: i64,
2032     pub TargetFileOffset: i64,
2033     pub ByteCount: i64,
2034 }
2035 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2036 impl ::core::marker::Copy for DUPLICATE_EXTENTS_DATA32 {}
2037 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2038 impl ::core::clone::Clone for DUPLICATE_EXTENTS_DATA32 {
2039     fn clone(&self) -> Self {
2040         *self
2041     }
2042 }
2043 #[repr(C)]
2044 #[cfg(feature = "Win32_Foundation")]
2045 pub struct DUPLICATE_EXTENTS_DATA_EX {
2046     pub Size: usize,
2047     pub FileHandle: super::super::Foundation::HANDLE,
2048     pub SourceFileOffset: i64,
2049     pub TargetFileOffset: i64,
2050     pub ByteCount: i64,
2051     pub Flags: u32,
2052 }
2053 #[cfg(feature = "Win32_Foundation")]
2054 impl ::core::marker::Copy for DUPLICATE_EXTENTS_DATA_EX {}
2055 #[cfg(feature = "Win32_Foundation")]
2056 impl ::core::clone::Clone for DUPLICATE_EXTENTS_DATA_EX {
2057     fn clone(&self) -> Self {
2058         *self
2059     }
2060 }
2061 #[repr(C)]
2062 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2063 pub struct DUPLICATE_EXTENTS_DATA_EX32 {
2064     pub Size: u32,
2065     pub FileHandle: u32,
2066     pub SourceFileOffset: i64,
2067     pub TargetFileOffset: i64,
2068     pub ByteCount: i64,
2069     pub Flags: u32,
2070 }
2071 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2072 impl ::core::marker::Copy for DUPLICATE_EXTENTS_DATA_EX32 {}
2073 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
2074 impl ::core::clone::Clone for DUPLICATE_EXTENTS_DATA_EX32 {
2075     fn clone(&self) -> Self {
2076         *self
2077     }
2078 }
2079 pub const DUPLICATE_EXTENTS_DATA_EX_ASYNC: u32 = 2u32;
2080 pub const DUPLICATE_EXTENTS_DATA_EX_SOURCE_ATOMIC: u32 = 1u32;
2081 pub type DUPLICATE_EXTENTS_STATE = i32;
2082 pub const FileSnapStateInactive: DUPLICATE_EXTENTS_STATE = 0i32;
2083 pub const FileSnapStateSource: DUPLICATE_EXTENTS_STATE = 1i32;
2084 pub const FileSnapStateTarget: DUPLICATE_EXTENTS_STATE = 2i32;
2085 pub const DeviceDsmActionFlag_NonDestructive: u32 = 2147483648u32;
2086 pub const EFS_TRACKED_OFFSET_HEADER_FLAG: u32 = 1u32;
2087 pub type ELEMENT_TYPE = i32;
2088 pub const AllElements: ELEMENT_TYPE = 0i32;
2089 pub const ChangerTransport: ELEMENT_TYPE = 1i32;
2090 pub const ChangerSlot: ELEMENT_TYPE = 2i32;
2091 pub const ChangerIEPort: ELEMENT_TYPE = 3i32;
2092 pub const ChangerDrive: ELEMENT_TYPE = 4i32;
2093 pub const ChangerDoor: ELEMENT_TYPE = 5i32;
2094 pub const ChangerKeypad: ELEMENT_TYPE = 6i32;
2095 pub const ChangerMaxElement: ELEMENT_TYPE = 7i32;
2096 pub const ENABLE_DISABLE_AUTOSAVE: u32 = 210u32;
2097 pub const ENABLE_DISABLE_AUTO_OFFLINE: u32 = 219u32;
2098 pub const ENABLE_SMART: u32 = 216u32;
2099 #[repr(C)]
2100 pub struct ENCRYPTED_DATA_INFO {
2101     pub StartingFileOffset: u64,
2102     pub OutputBufferOffset: u32,
2103     pub BytesWithinFileSize: u32,
2104     pub BytesWithinValidDataLength: u32,
2105     pub CompressionFormat: u16,
2106     pub DataUnitShift: u8,
2107     pub ChunkShift: u8,
2108     pub ClusterShift: u8,
2109     pub EncryptionFormat: u8,
2110     pub NumberOfDataBlocks: u16,
2111     pub DataBlockSize: [u32; 1],
2112 }
2113 impl ::core::marker::Copy for ENCRYPTED_DATA_INFO {}
2114 impl ::core::clone::Clone for ENCRYPTED_DATA_INFO {
2115     fn clone(&self) -> Self {
2116         *self
2117     }
2118 }
2119 pub const ENCRYPTED_DATA_INFO_SPARSE_FILE: u32 = 1u32;
2120 #[repr(C)]
2121 pub struct ENCRYPTION_BUFFER {
2122     pub EncryptionOperation: u32,
2123     pub Private: [u8; 1],
2124 }
2125 impl ::core::marker::Copy for ENCRYPTION_BUFFER {}
2126 impl ::core::clone::Clone for ENCRYPTION_BUFFER {
2127     fn clone(&self) -> Self {
2128         *self
2129     }
2130 }
2131 pub const ENCRYPTION_FORMAT_DEFAULT: u32 = 1u32;
2132 #[repr(C)]
2133 pub struct ENCRYPTION_KEY_CTRL_INPUT {
2134     pub HeaderSize: u32,
2135     pub StructureSize: u32,
2136     pub KeyOffset: u16,
2137     pub KeySize: u16,
2138     pub DplLock: u32,
2139     pub DplUserId: u64,
2140     pub DplCredentialId: u64,
2141 }
2142 impl ::core::marker::Copy for ENCRYPTION_KEY_CTRL_INPUT {}
2143 impl ::core::clone::Clone for ENCRYPTION_KEY_CTRL_INPUT {
2144     fn clone(&self) -> Self {
2145         *self
2146     }
2147 }
2148 pub const ERROR_DRIVE_NOT_INSTALLED: u32 = 8u32;
2149 pub const ERROR_HISTORY_DIRECTORY_ENTRY_DEFAULT_COUNT: u32 = 8u32;
2150 pub const ERROR_INIT_STATUS_NEEDED: u32 = 17u32;
2151 pub const ERROR_LABEL_QUESTIONABLE: u32 = 2u32;
2152 pub const ERROR_LABEL_UNREADABLE: u32 = 1u32;
2153 pub const ERROR_SLOT_NOT_PRESENT: u32 = 4u32;
2154 pub const ERROR_TRAY_MALFUNCTION: u32 = 16u32;
2155 pub const ERROR_UNHANDLED_ERROR: u32 = 4294967295u32;
2156 pub const EXECUTE_OFFLINE_DIAGS: u32 = 212u32;
2157 #[repr(C)]
2158 pub struct EXFAT_STATISTICS {
2159     pub CreateHits: u32,
2160     pub SuccessfulCreates: u32,
2161     pub FailedCreates: u32,
2162     pub NonCachedReads: u32,
2163     pub NonCachedReadBytes: u32,
2164     pub NonCachedWrites: u32,
2165     pub NonCachedWriteBytes: u32,
2166     pub NonCachedDiskReads: u32,
2167     pub NonCachedDiskWrites: u32,
2168 }
2169 impl ::core::marker::Copy for EXFAT_STATISTICS {}
2170 impl ::core::clone::Clone for EXFAT_STATISTICS {
2171     fn clone(&self) -> Self {
2172         *self
2173     }
2174 }
2175 #[repr(C)]
2176 pub struct EXTENDED_ENCRYPTED_DATA_INFO {
2177     pub ExtendedCode: u32,
2178     pub Length: u32,
2179     pub Flags: u32,
2180     pub Reserved: u32,
2181 }
2182 impl ::core::marker::Copy for EXTENDED_ENCRYPTED_DATA_INFO {}
2183 impl ::core::clone::Clone for EXTENDED_ENCRYPTED_DATA_INFO {
2184     fn clone(&self) -> Self {
2185         *self
2186     }
2187 }
2188 pub const EXTEND_IEPORT: u32 = 2u32;
2189 #[repr(C)]
2190 pub struct FAT_STATISTICS {
2191     pub CreateHits: u32,
2192     pub SuccessfulCreates: u32,
2193     pub FailedCreates: u32,
2194     pub NonCachedReads: u32,
2195     pub NonCachedReadBytes: u32,
2196     pub NonCachedWrites: u32,
2197     pub NonCachedWriteBytes: u32,
2198     pub NonCachedDiskReads: u32,
2199     pub NonCachedDiskWrites: u32,
2200 }
2201 impl ::core::marker::Copy for FAT_STATISTICS {}
2202 impl ::core::clone::Clone for FAT_STATISTICS {
2203     fn clone(&self) -> Self {
2204         *self
2205     }
2206 }
2207 #[repr(C)]
2208 pub struct FILESYSTEM_STATISTICS {
2209     pub FileSystemType: FILESYSTEM_STATISTICS_TYPE,
2210     pub Version: u16,
2211     pub SizeOfCompleteStructure: u32,
2212     pub UserFileReads: u32,
2213     pub UserFileReadBytes: u32,
2214     pub UserDiskReads: u32,
2215     pub UserFileWrites: u32,
2216     pub UserFileWriteBytes: u32,
2217     pub UserDiskWrites: u32,
2218     pub MetaDataReads: u32,
2219     pub MetaDataReadBytes: u32,
2220     pub MetaDataDiskReads: u32,
2221     pub MetaDataWrites: u32,
2222     pub MetaDataWriteBytes: u32,
2223     pub MetaDataDiskWrites: u32,
2224 }
2225 impl ::core::marker::Copy for FILESYSTEM_STATISTICS {}
2226 impl ::core::clone::Clone for FILESYSTEM_STATISTICS {
2227     fn clone(&self) -> Self {
2228         *self
2229     }
2230 }
2231 #[repr(C)]
2232 pub struct FILESYSTEM_STATISTICS_EX {
2233     pub FileSystemType: FILESYSTEM_STATISTICS_TYPE,
2234     pub Version: u16,
2235     pub SizeOfCompleteStructure: u32,
2236     pub UserFileReads: u64,
2237     pub UserFileReadBytes: u64,
2238     pub UserDiskReads: u64,
2239     pub UserFileWrites: u64,
2240     pub UserFileWriteBytes: u64,
2241     pub UserDiskWrites: u64,
2242     pub MetaDataReads: u64,
2243     pub MetaDataReadBytes: u64,
2244     pub MetaDataDiskReads: u64,
2245     pub MetaDataWrites: u64,
2246     pub MetaDataWriteBytes: u64,
2247     pub MetaDataDiskWrites: u64,
2248 }
2249 impl ::core::marker::Copy for FILESYSTEM_STATISTICS_EX {}
2250 impl ::core::clone::Clone for FILESYSTEM_STATISTICS_EX {
2251     fn clone(&self) -> Self {
2252         *self
2253     }
2254 }
2255 pub type FILESYSTEM_STATISTICS_TYPE = u16;
2256 pub const FILESYSTEM_STATISTICS_TYPE_EXFAT: FILESYSTEM_STATISTICS_TYPE = 3u16;
2257 pub const FILESYSTEM_STATISTICS_TYPE_FAT: FILESYSTEM_STATISTICS_TYPE = 2u16;
2258 pub const FILESYSTEM_STATISTICS_TYPE_NTFS: FILESYSTEM_STATISTICS_TYPE = 1u16;
2259 pub const FILESYSTEM_STATISTICS_TYPE_REFS: u32 = 4u32;
2260 #[repr(C)]
2261 pub struct FILE_ALLOCATED_RANGE_BUFFER {
2262     pub FileOffset: i64,
2263     pub Length: i64,
2264 }
2265 impl ::core::marker::Copy for FILE_ALLOCATED_RANGE_BUFFER {}
2266 impl ::core::clone::Clone for FILE_ALLOCATED_RANGE_BUFFER {
2267     fn clone(&self) -> Self {
2268         *self
2269     }
2270 }
2271 pub const FILE_ANY_ACCESS: u32 = 0u32;
2272 pub const FILE_CLEAR_ENCRYPTION: u32 = 2u32;
2273 #[repr(C)]
2274 pub struct FILE_DESIRED_STORAGE_CLASS_INFORMATION {
2275     pub Class: FILE_STORAGE_TIER_CLASS,
2276     pub Flags: u32,
2277 }
2278 impl ::core::marker::Copy for FILE_DESIRED_STORAGE_CLASS_INFORMATION {}
2279 impl ::core::clone::Clone for FILE_DESIRED_STORAGE_CLASS_INFORMATION {
2280     fn clone(&self) -> Self {
2281         *self
2282     }
2283 }
2284 pub const FILE_DEVICE_8042_PORT: u32 = 39u32;
2285 pub const FILE_DEVICE_ACPI: u32 = 50u32;
2286 pub const FILE_DEVICE_BATTERY: u32 = 41u32;
2287 pub const FILE_DEVICE_BEEP: u32 = 1u32;
2288 pub const FILE_DEVICE_BIOMETRIC: u32 = 68u32;
2289 pub const FILE_DEVICE_BLUETOOTH: u32 = 65u32;
2290 pub const FILE_DEVICE_BUS_EXTENDER: u32 = 42u32;
2291 pub const FILE_DEVICE_CD_ROM_FILE_SYSTEM: u32 = 3u32;
2292 pub const FILE_DEVICE_CHANGER: u32 = 48u32;
2293 pub const FILE_DEVICE_CONSOLE: u32 = 80u32;
2294 pub const FILE_DEVICE_CONTROLLER: u32 = 4u32;
2295 pub const FILE_DEVICE_CRYPT_PROVIDER: u32 = 63u32;
2296 pub const FILE_DEVICE_DATALINK: u32 = 5u32;
2297 pub const FILE_DEVICE_DEVAPI: u32 = 71u32;
2298 pub const FILE_DEVICE_DFS: u32 = 6u32;
2299 pub const FILE_DEVICE_DFS_FILE_SYSTEM: u32 = 53u32;
2300 pub const FILE_DEVICE_DFS_VOLUME: u32 = 54u32;
2301 pub const FILE_DEVICE_DISK_FILE_SYSTEM: u32 = 8u32;
2302 pub const FILE_DEVICE_EHSTOR: u32 = 70u32;
2303 pub const FILE_DEVICE_EVENT_COLLECTOR: u32 = 95u32;
2304 pub const FILE_DEVICE_FILE_SYSTEM: u32 = 9u32;
2305 pub const FILE_DEVICE_FIPS: u32 = 58u32;
2306 pub const FILE_DEVICE_FULLSCREEN_VIDEO: u32 = 52u32;
2307 pub const FILE_DEVICE_GPIO: u32 = 72u32;
2308 pub const FILE_DEVICE_HOLOGRAPHIC: u32 = 91u32;
2309 pub const FILE_DEVICE_INFINIBAND: u32 = 59u32;
2310 pub const FILE_DEVICE_INPORT_PORT: u32 = 10u32;
2311 pub const FILE_DEVICE_KEYBOARD: u32 = 11u32;
2312 pub const FILE_DEVICE_KS: u32 = 47u32;
2313 pub const FILE_DEVICE_KSEC: u32 = 57u32;
2314 pub const FILE_DEVICE_MAILSLOT: u32 = 12u32;
2315 pub const FILE_DEVICE_MASS_STORAGE: u32 = 45u32;
2316 pub const FILE_DEVICE_MIDI_IN: u32 = 13u32;
2317 pub const FILE_DEVICE_MIDI_OUT: u32 = 14u32;
2318 pub const FILE_DEVICE_MODEM: u32 = 43u32;
2319 pub const FILE_DEVICE_MOUSE: u32 = 15u32;
2320 pub const FILE_DEVICE_MT_COMPOSITE: u32 = 66u32;
2321 pub const FILE_DEVICE_MT_TRANSPORT: u32 = 67u32;
2322 pub const FILE_DEVICE_MULTI_UNC_PROVIDER: u32 = 16u32;
2323 pub const FILE_DEVICE_NAMED_PIPE: u32 = 17u32;
2324 pub const FILE_DEVICE_NETWORK: u32 = 18u32;
2325 pub const FILE_DEVICE_NETWORK_BROWSER: u32 = 19u32;
2326 pub const FILE_DEVICE_NETWORK_FILE_SYSTEM: u32 = 20u32;
2327 pub const FILE_DEVICE_NETWORK_REDIRECTOR: u32 = 40u32;
2328 pub const FILE_DEVICE_NFP: u32 = 81u32;
2329 pub const FILE_DEVICE_NULL: u32 = 21u32;
2330 pub const FILE_DEVICE_NVDIMM: u32 = 90u32;
2331 pub const FILE_DEVICE_PARALLEL_PORT: u32 = 22u32;
2332 pub const FILE_DEVICE_PERSISTENT_MEMORY: u32 = 89u32;
2333 pub const FILE_DEVICE_PHYSICAL_NETCARD: u32 = 23u32;
2334 pub const FILE_DEVICE_PMI: u32 = 69u32;
2335 pub const FILE_DEVICE_POINT_OF_SERVICE: u32 = 84u32;
2336 pub const FILE_DEVICE_PRINTER: u32 = 24u32;
2337 pub const FILE_DEVICE_PRM: u32 = 94u32;
2338 pub const FILE_DEVICE_SCANNER: u32 = 25u32;
2339 pub const FILE_DEVICE_SCREEN: u32 = 28u32;
2340 pub const FILE_DEVICE_SDFXHCI: u32 = 92u32;
2341 pub const FILE_DEVICE_SERENUM: u32 = 55u32;
2342 pub const FILE_DEVICE_SERIAL_MOUSE_PORT: u32 = 26u32;
2343 pub const FILE_DEVICE_SERIAL_PORT: u32 = 27u32;
2344 pub const FILE_DEVICE_SMB: u32 = 46u32;
2345 pub const FILE_DEVICE_SOUND: u32 = 29u32;
2346 pub const FILE_DEVICE_SOUNDWIRE: u32 = 97u32;
2347 pub const FILE_DEVICE_STORAGE_REPLICATION: u32 = 85u32;
2348 pub const FILE_DEVICE_STREAMS: u32 = 30u32;
2349 pub const FILE_DEVICE_SYSENV: u32 = 82u32;
2350 pub const FILE_DEVICE_TAPE_FILE_SYSTEM: u32 = 32u32;
2351 pub const FILE_DEVICE_TERMSRV: u32 = 56u32;
2352 pub const FILE_DEVICE_TRANSPORT: u32 = 33u32;
2353 pub const FILE_DEVICE_TRUST_ENV: u32 = 86u32;
2354 pub const FILE_DEVICE_UCM: u32 = 87u32;
2355 pub const FILE_DEVICE_UCMTCPCI: u32 = 88u32;
2356 pub const FILE_DEVICE_UCMUCSI: u32 = 93u32;
2357 pub const FILE_DEVICE_UNKNOWN: u32 = 34u32;
2358 pub const FILE_DEVICE_USB4: u32 = 96u32;
2359 pub const FILE_DEVICE_USBEX: u32 = 73u32;
2360 pub const FILE_DEVICE_VDM: u32 = 44u32;
2361 pub const FILE_DEVICE_VIDEO: u32 = 35u32;
2362 pub const FILE_DEVICE_VIRTUAL_BLOCK: u32 = 83u32;
2363 pub const FILE_DEVICE_VIRTUAL_DISK: u32 = 36u32;
2364 pub const FILE_DEVICE_VMBUS: u32 = 62u32;
2365 pub const FILE_DEVICE_WAVE_IN: u32 = 37u32;
2366 pub const FILE_DEVICE_WAVE_OUT: u32 = 38u32;
2367 pub const FILE_DEVICE_WPD: u32 = 64u32;
2368 #[repr(C)]
2369 pub struct FILE_FS_PERSISTENT_VOLUME_INFORMATION {
2370     pub VolumeFlags: u32,
2371     pub FlagMask: u32,
2372     pub Version: u32,
2373     pub Reserved: u32,
2374 }
2375 impl ::core::marker::Copy for FILE_FS_PERSISTENT_VOLUME_INFORMATION {}
2376 impl ::core::clone::Clone for FILE_FS_PERSISTENT_VOLUME_INFORMATION {
2377     fn clone(&self) -> Self {
2378         *self
2379     }
2380 }
2381 pub const FILE_INITIATE_REPAIR_HINT1_ATTRIBUTE_NON_RESIDENT: u64 = 137438953472u64;
2382 pub const FILE_INITIATE_REPAIR_HINT1_ATTRIBUTE_NOT_FOUND: u64 = 4096u64;
2383 pub const FILE_INITIATE_REPAIR_HINT1_ATTRIBUTE_TOO_SMALL: u64 = 68719476736u64;
2384 pub const FILE_INITIATE_REPAIR_HINT1_CLUSTERS_ALREADY_IN_USE: u64 = 32768u64;
2385 pub const FILE_INITIATE_REPAIR_HINT1_DENY_DEFRAG: u64 = 274877906944u64;
2386 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_IS_BASE_RECORD: u64 = 524288u64;
2387 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_NOT_BASE_RECORD: u64 = 8u64;
2388 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_NOT_EXIST: u64 = 4u64;
2389 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_NOT_IN_USE: u64 = 1u64;
2390 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_NOT_ORPHAN: u64 = 262144u64;
2391 pub const FILE_INITIATE_REPAIR_HINT1_FILE_RECORD_REUSED: u64 = 2u64;
2392 pub const FILE_INITIATE_REPAIR_HINT1_INDEX_ENTRY_MISMATCH: u64 = 1099511627776u64;
2393 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_ARRAY_LENGTH_COUNT: u64 = 1048576u64;
2394 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_LCN: u64 = 4294967296u64;
2395 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_ORPHAN_RECOVERY_NAME: u64 = 2199023255552u64;
2396 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_PARENT: u64 = 8388608u64;
2397 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_RUN_LENGTH: u64 = 131072u64;
2398 pub const FILE_INITIATE_REPAIR_HINT1_INVALID_VCN: u64 = 8589934592u64;
2399 pub const FILE_INITIATE_REPAIR_HINT1_LCN_NOT_EXIST: u64 = 65536u64;
2400 pub const FILE_INITIATE_REPAIR_HINT1_MULTIPLE_FILE_NAME_ATTRIBUTES: u64 = 4398046511104u64;
2401 pub const FILE_INITIATE_REPAIR_HINT1_NAME_CONFLICT: u64 = 17179869184u64;
2402 pub const FILE_INITIATE_REPAIR_HINT1_NOTHING_WRONG: u64 = 2048u64;
2403 pub const FILE_INITIATE_REPAIR_HINT1_NOT_IMPLEMENTED: u64 = 32u64;
2404 pub const FILE_INITIATE_REPAIR_HINT1_ORPHAN: u64 = 34359738368u64;
2405 pub const FILE_INITIATE_REPAIR_HINT1_ORPHAN_GENERATED: u64 = 512u64;
2406 pub const FILE_INITIATE_REPAIR_HINT1_OUT_OF_GENERIC_NAMES: u64 = 1073741824u64;
2407 pub const FILE_INITIATE_REPAIR_HINT1_OUT_OF_RESOURCE: u64 = 2147483648u64;
2408 pub const FILE_INITIATE_REPAIR_HINT1_PARENT_FILE_RECORD_NOT_BASE_RECORD: u64 = 134217728u64;
2409 pub const FILE_INITIATE_REPAIR_HINT1_PARENT_FILE_RECORD_NOT_EXIST: u64 = 67108864u64;
2410 pub const FILE_INITIATE_REPAIR_HINT1_PARENT_FILE_RECORD_NOT_INDEX: u64 = 268435456u64;
2411 pub const FILE_INITIATE_REPAIR_HINT1_PARENT_FILE_RECORD_NOT_IN_USE: u64 = 16777216u64;
2412 pub const FILE_INITIATE_REPAIR_HINT1_PARENT_FILE_RECORD_REUSED: u64 = 33554432u64;
2413 pub const FILE_INITIATE_REPAIR_HINT1_POTENTIAL_CROSSLINK: u64 = 8192u64;
2414 pub const FILE_INITIATE_REPAIR_HINT1_PREVIOUS_PARENT_STILL_VALID: u64 = 549755813888u64;
2415 pub const FILE_INITIATE_REPAIR_HINT1_RECURSIVELY_CORRUPTED: u64 = 256u64;
2416 pub const FILE_INITIATE_REPAIR_HINT1_REPAIRED: u64 = 1024u64;
2417 pub const FILE_INITIATE_REPAIR_HINT1_REPAIR_DISABLED: u64 = 128u64;
2418 pub const FILE_INITIATE_REPAIR_HINT1_SID_MISMATCH: u64 = 4194304u64;
2419 pub const FILE_INITIATE_REPAIR_HINT1_SID_VALID: u64 = 2097152u64;
2420 pub const FILE_INITIATE_REPAIR_HINT1_STALE_INFORMATION: u64 = 16384u64;
2421 pub const FILE_INITIATE_REPAIR_HINT1_SYSTEM_FILE: u64 = 16u64;
2422 pub const FILE_INITIATE_REPAIR_HINT1_UNABLE_TO_REPAIR: u64 = 64u64;
2423 pub const FILE_INITIATE_REPAIR_HINT1_VALID_INDEX_ENTRY: u64 = 536870912u64;
2424 #[repr(C)]
2425 pub struct FILE_INITIATE_REPAIR_OUTPUT_BUFFER {
2426     pub Hint1: u64,
2427     pub Hint2: u64,
2428     pub Clsn: u64,
2429     pub Status: u32,
2430 }
2431 impl ::core::marker::Copy for FILE_INITIATE_REPAIR_OUTPUT_BUFFER {}
2432 impl ::core::clone::Clone for FILE_INITIATE_REPAIR_OUTPUT_BUFFER {
2433     fn clone(&self) -> Self {
2434         *self
2435     }
2436 }
2437 #[repr(C)]
2438 pub struct FILE_LAYOUT_ENTRY {
2439     pub Version: u32,
2440     pub NextFileOffset: u32,
2441     pub Flags: u32,
2442     pub FileAttributes: u32,
2443     pub FileReferenceNumber: u64,
2444     pub FirstNameOffset: u32,
2445     pub FirstStreamOffset: u32,
2446     pub ExtraInfoOffset: u32,
2447     pub ExtraInfoLength: u32,
2448 }
2449 impl ::core::marker::Copy for FILE_LAYOUT_ENTRY {}
2450 impl ::core::clone::Clone for FILE_LAYOUT_ENTRY {
2451     fn clone(&self) -> Self {
2452         *self
2453     }
2454 }
2455 #[repr(C)]
2456 pub struct FILE_LAYOUT_INFO_ENTRY {
2457     pub BasicInformation: FILE_LAYOUT_INFO_ENTRY_0,
2458     pub OwnerId: u32,
2459     pub SecurityId: u32,
2460     pub Usn: i64,
2461     pub StorageReserveId: STORAGE_RESERVE_ID,
2462 }
2463 impl ::core::marker::Copy for FILE_LAYOUT_INFO_ENTRY {}
2464 impl ::core::clone::Clone for FILE_LAYOUT_INFO_ENTRY {
2465     fn clone(&self) -> Self {
2466         *self
2467     }
2468 }
2469 #[repr(C)]
2470 pub struct FILE_LAYOUT_INFO_ENTRY_0 {
2471     pub CreationTime: i64,
2472     pub LastAccessTime: i64,
2473     pub LastWriteTime: i64,
2474     pub ChangeTime: i64,
2475     pub FileAttributes: u32,
2476 }
2477 impl ::core::marker::Copy for FILE_LAYOUT_INFO_ENTRY_0 {}
2478 impl ::core::clone::Clone for FILE_LAYOUT_INFO_ENTRY_0 {
2479     fn clone(&self) -> Self {
2480         *self
2481     }
2482 }
2483 #[repr(C)]
2484 pub struct FILE_LAYOUT_NAME_ENTRY {
2485     pub NextNameOffset: u32,
2486     pub Flags: u32,
2487     pub ParentFileReferenceNumber: u64,
2488     pub FileNameLength: u32,
2489     pub Reserved: u32,
2490     pub FileName: [u16; 1],
2491 }
2492 impl ::core::marker::Copy for FILE_LAYOUT_NAME_ENTRY {}
2493 impl ::core::clone::Clone for FILE_LAYOUT_NAME_ENTRY {
2494     fn clone(&self) -> Self {
2495         *self
2496     }
2497 }
2498 pub const FILE_LAYOUT_NAME_ENTRY_DOS: u32 = 2u32;
2499 pub const FILE_LAYOUT_NAME_ENTRY_PRIMARY: u32 = 1u32;
2500 #[repr(C)]
2501 pub struct FILE_LEVEL_TRIM {
2502     pub Key: u32,
2503     pub NumRanges: u32,
2504     pub Ranges: [FILE_LEVEL_TRIM_RANGE; 1],
2505 }
2506 impl ::core::marker::Copy for FILE_LEVEL_TRIM {}
2507 impl ::core::clone::Clone for FILE_LEVEL_TRIM {
2508     fn clone(&self) -> Self {
2509         *self
2510     }
2511 }
2512 #[repr(C)]
2513 pub struct FILE_LEVEL_TRIM_OUTPUT {
2514     pub NumRangesProcessed: u32,
2515 }
2516 impl ::core::marker::Copy for FILE_LEVEL_TRIM_OUTPUT {}
2517 impl ::core::clone::Clone for FILE_LEVEL_TRIM_OUTPUT {
2518     fn clone(&self) -> Self {
2519         *self
2520     }
2521 }
2522 #[repr(C)]
2523 pub struct FILE_LEVEL_TRIM_RANGE {
2524     pub Offset: u64,
2525     pub Length: u64,
2526 }
2527 impl ::core::marker::Copy for FILE_LEVEL_TRIM_RANGE {}
2528 impl ::core::clone::Clone for FILE_LEVEL_TRIM_RANGE {
2529     fn clone(&self) -> Self {
2530         *self
2531     }
2532 }
2533 #[repr(C)]
2534 #[cfg(feature = "Win32_Foundation")]
2535 pub struct FILE_MAKE_COMPATIBLE_BUFFER {
2536     pub CloseDisc: super::super::Foundation::BOOLEAN,
2537 }
2538 #[cfg(feature = "Win32_Foundation")]
2539 impl ::core::marker::Copy for FILE_MAKE_COMPATIBLE_BUFFER {}
2540 #[cfg(feature = "Win32_Foundation")]
2541 impl ::core::clone::Clone for FILE_MAKE_COMPATIBLE_BUFFER {
2542     fn clone(&self) -> Self {
2543         *self
2544     }
2545 }
2546 #[repr(C)]
2547 pub struct FILE_OBJECTID_BUFFER {
2548     pub ObjectId: [u8; 16],
2549     pub Anonymous: FILE_OBJECTID_BUFFER_0,
2550 }
2551 impl ::core::marker::Copy for FILE_OBJECTID_BUFFER {}
2552 impl ::core::clone::Clone for FILE_OBJECTID_BUFFER {
2553     fn clone(&self) -> Self {
2554         *self
2555     }
2556 }
2557 #[repr(C)]
2558 pub union FILE_OBJECTID_BUFFER_0 {
2559     pub Anonymous: FILE_OBJECTID_BUFFER_0_0,
2560     pub ExtendedInfo: [u8; 48],
2561 }
2562 impl ::core::marker::Copy for FILE_OBJECTID_BUFFER_0 {}
2563 impl ::core::clone::Clone for FILE_OBJECTID_BUFFER_0 {
2564     fn clone(&self) -> Self {
2565         *self
2566     }
2567 }
2568 #[repr(C)]
2569 pub struct FILE_OBJECTID_BUFFER_0_0 {
2570     pub BirthVolumeId: [u8; 16],
2571     pub BirthObjectId: [u8; 16],
2572     pub DomainId: [u8; 16],
2573 }
2574 impl ::core::marker::Copy for FILE_OBJECTID_BUFFER_0_0 {}
2575 impl ::core::clone::Clone for FILE_OBJECTID_BUFFER_0_0 {
2576     fn clone(&self) -> Self {
2577         *self
2578     }
2579 }
2580 #[repr(C)]
2581 pub struct FILE_PREFETCH {
2582     pub Type: u32,
2583     pub Count: u32,
2584     pub Prefetch: [u64; 1],
2585 }
2586 impl ::core::marker::Copy for FILE_PREFETCH {}
2587 impl ::core::clone::Clone for FILE_PREFETCH {
2588     fn clone(&self) -> Self {
2589         *self
2590     }
2591 }
2592 #[repr(C)]
2593 pub struct FILE_PREFETCH_EX {
2594     pub Type: u32,
2595     pub Count: u32,
2596     pub Context: *mut ::core::ffi::c_void,
2597     pub Prefetch: [u64; 1],
2598 }
2599 impl ::core::marker::Copy for FILE_PREFETCH_EX {}
2600 impl ::core::clone::Clone for FILE_PREFETCH_EX {
2601     fn clone(&self) -> Self {
2602         *self
2603     }
2604 }
2605 pub const FILE_PREFETCH_TYPE_FOR_CREATE: u32 = 1u32;
2606 pub const FILE_PREFETCH_TYPE_FOR_CREATE_EX: u32 = 3u32;
2607 pub const FILE_PREFETCH_TYPE_FOR_DIRENUM: u32 = 2u32;
2608 pub const FILE_PREFETCH_TYPE_FOR_DIRENUM_EX: u32 = 4u32;
2609 pub const FILE_PREFETCH_TYPE_MAX: u32 = 4u32;
2610 pub const FILE_PROVIDER_COMPRESSION_MAXIMUM: u32 = 4u32;
2611 pub const FILE_PROVIDER_CURRENT_VERSION: u32 = 1u32;
2612 #[repr(C)]
2613 pub struct FILE_PROVIDER_EXTERNAL_INFO_V0 {
2614     pub Version: u32,
2615     pub Algorithm: u32,
2616 }
2617 impl ::core::marker::Copy for FILE_PROVIDER_EXTERNAL_INFO_V0 {}
2618 impl ::core::clone::Clone for FILE_PROVIDER_EXTERNAL_INFO_V0 {
2619     fn clone(&self) -> Self {
2620         *self
2621     }
2622 }
2623 #[repr(C)]
2624 pub struct FILE_PROVIDER_EXTERNAL_INFO_V1 {
2625     pub Version: u32,
2626     pub Algorithm: u32,
2627     pub Flags: u32,
2628 }
2629 impl ::core::marker::Copy for FILE_PROVIDER_EXTERNAL_INFO_V1 {}
2630 impl ::core::clone::Clone for FILE_PROVIDER_EXTERNAL_INFO_V1 {
2631     fn clone(&self) -> Self {
2632         *self
2633     }
2634 }
2635 pub const FILE_PROVIDER_FLAG_COMPRESS_ON_WRITE: u32 = 1u32;
2636 pub const FILE_PROVIDER_SINGLE_FILE: u32 = 1u32;
2637 #[repr(C)]
2638 pub struct FILE_QUERY_ON_DISK_VOL_INFO_BUFFER {
2639     pub DirectoryCount: i64,
2640     pub FileCount: i64,
2641     pub FsFormatMajVersion: u16,
2642     pub FsFormatMinVersion: u16,
2643     pub FsFormatName: [u16; 12],
2644     pub FormatTime: i64,
2645     pub LastUpdateTime: i64,
2646     pub CopyrightInfo: [u16; 34],
2647     pub AbstractInfo: [u16; 34],
2648     pub FormattingImplementationInfo: [u16; 34],
2649     pub LastModifyingImplementationInfo: [u16; 34],
2650 }
2651 impl ::core::marker::Copy for FILE_QUERY_ON_DISK_VOL_INFO_BUFFER {}
2652 impl ::core::clone::Clone for FILE_QUERY_ON_DISK_VOL_INFO_BUFFER {
2653     fn clone(&self) -> Self {
2654         *self
2655     }
2656 }
2657 #[repr(C)]
2658 #[cfg(feature = "Win32_Foundation")]
2659 pub struct FILE_QUERY_SPARING_BUFFER {
2660     pub SparingUnitBytes: u32,
2661     pub SoftwareSparing: super::super::Foundation::BOOLEAN,
2662     pub TotalSpareBlocks: u32,
2663     pub FreeSpareBlocks: u32,
2664 }
2665 #[cfg(feature = "Win32_Foundation")]
2666 impl ::core::marker::Copy for FILE_QUERY_SPARING_BUFFER {}
2667 #[cfg(feature = "Win32_Foundation")]
2668 impl ::core::clone::Clone for FILE_QUERY_SPARING_BUFFER {
2669     fn clone(&self) -> Self {
2670         *self
2671     }
2672 }
2673 pub const FILE_READ_ACCESS: u32 = 1u32;
2674 #[repr(C)]
2675 pub struct FILE_REFERENCE_RANGE {
2676     pub StartingFileReferenceNumber: u64,
2677     pub EndingFileReferenceNumber: u64,
2678 }
2679 impl ::core::marker::Copy for FILE_REFERENCE_RANGE {}
2680 impl ::core::clone::Clone for FILE_REFERENCE_RANGE {
2681     fn clone(&self) -> Self {
2682         *self
2683     }
2684 }
2685 #[repr(C)]
2686 pub struct FILE_REGION_INFO {
2687     pub FileOffset: i64,
2688     pub Length: i64,
2689     pub Usage: u32,
2690     pub Reserved: u32,
2691 }
2692 impl ::core::marker::Copy for FILE_REGION_INFO {}
2693 impl ::core::clone::Clone for FILE_REGION_INFO {
2694     fn clone(&self) -> Self {
2695         *self
2696     }
2697 }
2698 #[repr(C)]
2699 pub struct FILE_REGION_INPUT {
2700     pub FileOffset: i64,
2701     pub Length: i64,
2702     pub DesiredUsage: u32,
2703 }
2704 impl ::core::marker::Copy for FILE_REGION_INPUT {}
2705 impl ::core::clone::Clone for FILE_REGION_INPUT {
2706     fn clone(&self) -> Self {
2707         *self
2708     }
2709 }
2710 #[repr(C)]
2711 pub struct FILE_REGION_OUTPUT {
2712     pub Flags: u32,
2713     pub TotalRegionEntryCount: u32,
2714     pub RegionEntryCount: u32,
2715     pub Reserved: u32,
2716     pub Region: [FILE_REGION_INFO; 1],
2717 }
2718 impl ::core::marker::Copy for FILE_REGION_OUTPUT {}
2719 impl ::core::clone::Clone for FILE_REGION_OUTPUT {
2720     fn clone(&self) -> Self {
2721         *self
2722     }
2723 }
2724 pub const FILE_REGION_USAGE_HUGE_PAGE_ALIGNMENT: u32 = 16u32;
2725 pub const FILE_REGION_USAGE_LARGE_PAGE_ALIGNMENT: u32 = 8u32;
2726 pub const FILE_REGION_USAGE_OTHER_PAGE_ALIGNMENT: u32 = 4u32;
2727 pub const FILE_REGION_USAGE_QUERY_ALIGNMENT: u32 = 8u32;
2728 pub const FILE_REGION_USAGE_VALID_CACHED_DATA: u32 = 1u32;
2729 pub const FILE_REGION_USAGE_VALID_NONCACHED_DATA: u32 = 2u32;
2730 #[repr(C)]
2731 #[cfg(feature = "Win32_Foundation")]
2732 pub struct FILE_SET_DEFECT_MGMT_BUFFER {
2733     pub Disable: super::super::Foundation::BOOLEAN,
2734 }
2735 #[cfg(feature = "Win32_Foundation")]
2736 impl ::core::marker::Copy for FILE_SET_DEFECT_MGMT_BUFFER {}
2737 #[cfg(feature = "Win32_Foundation")]
2738 impl ::core::clone::Clone for FILE_SET_DEFECT_MGMT_BUFFER {
2739     fn clone(&self) -> Self {
2740         *self
2741     }
2742 }
2743 pub const FILE_SET_ENCRYPTION: u32 = 1u32;
2744 #[repr(C)]
2745 #[cfg(feature = "Win32_Foundation")]
2746 pub struct FILE_SET_SPARSE_BUFFER {
2747     pub SetSparse: super::super::Foundation::BOOLEAN,
2748 }
2749 #[cfg(feature = "Win32_Foundation")]
2750 impl ::core::marker::Copy for FILE_SET_SPARSE_BUFFER {}
2751 #[cfg(feature = "Win32_Foundation")]
2752 impl ::core::clone::Clone for FILE_SET_SPARSE_BUFFER {
2753     fn clone(&self) -> Self {
2754         *self
2755     }
2756 }
2757 pub const FILE_SPECIAL_ACCESS: u32 = 0u32;
2758 #[repr(C)]
2759 pub struct FILE_STORAGE_TIER {
2760     pub Id: ::windows_sys::core::GUID,
2761     pub Name: [u16; 256],
2762     pub Description: [u16; 256],
2763     pub Flags: FILE_STORAGE_TIER_FLAGS,
2764     pub ProvisionedCapacity: u64,
2765     pub MediaType: FILE_STORAGE_TIER_MEDIA_TYPE,
2766     pub Class: FILE_STORAGE_TIER_CLASS,
2767 }
2768 impl ::core::marker::Copy for FILE_STORAGE_TIER {}
2769 impl ::core::clone::Clone for FILE_STORAGE_TIER {
2770     fn clone(&self) -> Self {
2771         *self
2772     }
2773 }
2774 pub type FILE_STORAGE_TIER_CLASS = i32;
2775 pub const FileStorageTierClassUnspecified: FILE_STORAGE_TIER_CLASS = 0i32;
2776 pub const FileStorageTierClassCapacity: FILE_STORAGE_TIER_CLASS = 1i32;
2777 pub const FileStorageTierClassPerformance: FILE_STORAGE_TIER_CLASS = 2i32;
2778 pub const FileStorageTierClassMax: FILE_STORAGE_TIER_CLASS = 3i32;
2779 pub const FILE_STORAGE_TIER_DESCRIPTION_LENGTH: u32 = 512u32;
2780 pub type FILE_STORAGE_TIER_FLAGS = u32;
2781 pub const FILE_STORAGE_TIER_FLAG_NO_SEEK_PENALTY: FILE_STORAGE_TIER_FLAGS = 131072u32;
2782 pub const FILE_STORAGE_TIER_FLAG_PARITY: u32 = 8388608u32;
2783 pub const FILE_STORAGE_TIER_FLAG_READ_CACHE: u32 = 4194304u32;
2784 pub const FILE_STORAGE_TIER_FLAG_SMR: u32 = 16777216u32;
2785 pub const FILE_STORAGE_TIER_FLAG_WRITE_BACK_CACHE: u32 = 2097152u32;
2786 pub type FILE_STORAGE_TIER_MEDIA_TYPE = i32;
2787 pub const FileStorageTierMediaTypeUnspecified: FILE_STORAGE_TIER_MEDIA_TYPE = 0i32;
2788 pub const FileStorageTierMediaTypeDisk: FILE_STORAGE_TIER_MEDIA_TYPE = 1i32;
2789 pub const FileStorageTierMediaTypeSsd: FILE_STORAGE_TIER_MEDIA_TYPE = 2i32;
2790 pub const FileStorageTierMediaTypeScm: FILE_STORAGE_TIER_MEDIA_TYPE = 4i32;
2791 pub const FileStorageTierMediaTypeMax: FILE_STORAGE_TIER_MEDIA_TYPE = 5i32;
2792 pub const FILE_STORAGE_TIER_NAME_LENGTH: u32 = 256u32;
2793 #[repr(C)]
2794 pub struct FILE_STORAGE_TIER_REGION {
2795     pub TierId: ::windows_sys::core::GUID,
2796     pub Offset: u64,
2797     pub Length: u64,
2798 }
2799 impl ::core::marker::Copy for FILE_STORAGE_TIER_REGION {}
2800 impl ::core::clone::Clone for FILE_STORAGE_TIER_REGION {
2801     fn clone(&self) -> Self {
2802         *self
2803     }
2804 }
2805 #[repr(C)]
2806 #[cfg(feature = "Win32_Foundation")]
2807 pub struct FILE_SYSTEM_RECOGNITION_INFORMATION {
2808     pub FileSystem: [super::super::Foundation::CHAR; 9],
2809 }
2810 #[cfg(feature = "Win32_Foundation")]
2811 impl ::core::marker::Copy for FILE_SYSTEM_RECOGNITION_INFORMATION {}
2812 #[cfg(feature = "Win32_Foundation")]
2813 impl ::core::clone::Clone for FILE_SYSTEM_RECOGNITION_INFORMATION {
2814     fn clone(&self) -> Self {
2815         *self
2816     }
2817 }
2818 pub const FILE_TYPE_NOTIFICATION_FLAG_USAGE_BEGIN: u32 = 1u32;
2819 pub const FILE_TYPE_NOTIFICATION_FLAG_USAGE_END: u32 = 2u32;
2820 pub const FILE_TYPE_NOTIFICATION_GUID_CRASHDUMP_FILE: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
2821     data1: 2638560951,
2822     data2: 53926,
2823     data3: 19901,
2824     data4: [162, 227, 251, 208, 237, 145, 9, 169],
2825 };
2826 pub const FILE_TYPE_NOTIFICATION_GUID_HIBERNATION_FILE: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
2827     data1: 3076672868,
2828     data2: 47523,
2829     data3: 19704,
2830     data4: [128, 17, 91, 134, 201, 64, 231, 183],
2831 };
2832 pub const FILE_TYPE_NOTIFICATION_GUID_PAGE_FILE: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 218784929, data2: 14588, data3: 19896, data4: [159, 231, 63, 67, 82, 205, 124, 92] };
2833 #[repr(C)]
2834 pub struct FILE_TYPE_NOTIFICATION_INPUT {
2835     pub Flags: u32,
2836     pub NumFileTypeIDs: u32,
2837     pub FileTypeID: [::windows_sys::core::GUID; 1],
2838 }
2839 impl ::core::marker::Copy for FILE_TYPE_NOTIFICATION_INPUT {}
2840 impl ::core::clone::Clone for FILE_TYPE_NOTIFICATION_INPUT {
2841     fn clone(&self) -> Self {
2842         *self
2843     }
2844 }
2845 pub const FILE_WRITE_ACCESS: u32 = 2u32;
2846 #[repr(C)]
2847 pub struct FILE_ZERO_DATA_INFORMATION {
2848     pub FileOffset: i64,
2849     pub BeyondFinalZero: i64,
2850 }
2851 impl ::core::marker::Copy for FILE_ZERO_DATA_INFORMATION {}
2852 impl ::core::clone::Clone for FILE_ZERO_DATA_INFORMATION {
2853     fn clone(&self) -> Self {
2854         *self
2855     }
2856 }
2857 #[repr(C)]
2858 pub struct FILE_ZERO_DATA_INFORMATION_EX {
2859     pub FileOffset: i64,
2860     pub BeyondFinalZero: i64,
2861     pub Flags: u32,
2862 }
2863 impl ::core::marker::Copy for FILE_ZERO_DATA_INFORMATION_EX {}
2864 impl ::core::clone::Clone for FILE_ZERO_DATA_INFORMATION_EX {
2865     fn clone(&self) -> Self {
2866         *self
2867     }
2868 }
2869 pub const FILE_ZERO_DATA_INFORMATION_FLAG_PRESERVE_CACHED_DATA: u32 = 1u32;
2870 #[repr(C)]
2871 #[cfg(feature = "Win32_Security")]
2872 pub struct FIND_BY_SID_DATA {
2873     pub Restart: u32,
2874     pub Sid: super::super::Security::SID,
2875 }
2876 #[cfg(feature = "Win32_Security")]
2877 impl ::core::marker::Copy for FIND_BY_SID_DATA {}
2878 #[cfg(feature = "Win32_Security")]
2879 impl ::core::clone::Clone for FIND_BY_SID_DATA {
2880     fn clone(&self) -> Self {
2881         *self
2882     }
2883 }
2884 #[repr(C)]
2885 pub struct FIND_BY_SID_OUTPUT {
2886     pub NextEntryOffset: u32,
2887     pub FileIndex: u32,
2888     pub FileNameLength: u32,
2889     pub FileName: [u16; 1],
2890 }
2891 impl ::core::marker::Copy for FIND_BY_SID_OUTPUT {}
2892 impl ::core::clone::Clone for FIND_BY_SID_OUTPUT {
2893     fn clone(&self) -> Self {
2894         *self
2895     }
2896 }
2897 pub const FLAG_USN_TRACK_MODIFIED_RANGES_ENABLE: u32 = 1u32;
2898 #[repr(C)]
2899 pub struct FORMAT_EX_PARAMETERS {
2900     pub MediaType: MEDIA_TYPE,
2901     pub StartCylinderNumber: u32,
2902     pub EndCylinderNumber: u32,
2903     pub StartHeadNumber: u32,
2904     pub EndHeadNumber: u32,
2905     pub FormatGapLength: u16,
2906     pub SectorsPerTrack: u16,
2907     pub SectorNumber: [u16; 1],
2908 }
2909 impl ::core::marker::Copy for FORMAT_EX_PARAMETERS {}
2910 impl ::core::clone::Clone for FORMAT_EX_PARAMETERS {
2911     fn clone(&self) -> Self {
2912         *self
2913     }
2914 }
2915 #[repr(C)]
2916 pub struct FORMAT_PARAMETERS {
2917     pub MediaType: MEDIA_TYPE,
2918     pub StartCylinderNumber: u32,
2919     pub EndCylinderNumber: u32,
2920     pub StartHeadNumber: u32,
2921     pub EndHeadNumber: u32,
2922 }
2923 impl ::core::marker::Copy for FORMAT_PARAMETERS {}
2924 impl ::core::clone::Clone for FORMAT_PARAMETERS {
2925     fn clone(&self) -> Self {
2926         *self
2927     }
2928 }
2929 pub const FSCTL_ADD_OVERLAY: u32 = 623408u32;
2930 pub const FSCTL_ADVANCE_FILE_ID: u32 = 590532u32;
2931 pub const FSCTL_ALLOW_EXTENDED_DASD_IO: u32 = 589955u32;
2932 pub const FSCTL_CLEAN_VOLUME_METADATA: u32 = 590716u32;
2933 pub const FSCTL_CORRUPTION_HANDLING: u32 = 590432u32;
2934 pub const FSCTL_CREATE_OR_GET_OBJECT_ID: u32 = 590016u32;
2935 pub const FSCTL_CREATE_USN_JOURNAL: u32 = 590055u32;
2936 pub const FSCTL_CSC_INTERNAL: u32 = 590255u32;
2937 pub const FSCTL_CSV_CONTROL: u32 = 590548u32;
2938 pub const FSCTL_CSV_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT: u32 = 590420u32;
2939 pub const FSCTL_CSV_GET_VOLUME_PATH_NAME: u32 = 590416u32;
2940 pub const FSCTL_CSV_GET_VOLUME_PATH_NAMES_FOR_VOLUME_NAME: u32 = 590424u32;
2941 pub const FSCTL_CSV_H_BREAKING_SYNC_TUNNEL_REQUEST: u32 = 590564u32;
2942 pub const FSCTL_CSV_INTERNAL: u32 = 590444u32;
2943 pub const FSCTL_CSV_MGMT_LOCK: u32 = 590524u32;
2944 pub const FSCTL_CSV_QUERY_DOWN_LEVEL_FILE_SYSTEM_CHARACTERISTICS: u32 = 590528u32;
2945 pub const FSCTL_CSV_QUERY_VETO_FILE_DIRECT_IO: u32 = 590540u32;
2946 pub const FSCTL_CSV_SYNC_TUNNEL_REQUEST: u32 = 590536u32;
2947 pub const FSCTL_CSV_TUNNEL_REQUEST: u32 = 590404u32;
2948 pub const FSCTL_DELETE_CORRUPTED_REFS_CONTAINER: u32 = 590836u32;
2949 pub const FSCTL_DELETE_EXTERNAL_BACKING: u32 = 590612u32;
2950 pub const FSCTL_DELETE_OBJECT_ID: u32 = 589984u32;
2951 pub const FSCTL_DELETE_REPARSE_POINT: u32 = 589996u32;
2952 pub const FSCTL_DELETE_USN_JOURNAL: u32 = 590072u32;
2953 pub const FSCTL_DFSR_SET_GHOST_HANDLE_STATE: u32 = 590264u32;
2954 pub const FSCTL_DISABLE_LOCAL_BUFFERING: u32 = 590520u32;
2955 pub const FSCTL_DISMOUNT_VOLUME: u32 = 589856u32;
2956 pub const FSCTL_DUPLICATE_EXTENTS_TO_FILE: u32 = 623428u32;
2957 pub const FSCTL_DUPLICATE_EXTENTS_TO_FILE_EX: u32 = 623592u32;
2958 pub const FSCTL_ENABLE_PER_IO_FLAGS: u32 = 590892u32;
2959 pub const FSCTL_ENABLE_UPGRADE: u32 = 622800u32;
2960 pub const FSCTL_ENCRYPTION_FSCTL_IO: u32 = 590043u32;
2961 pub const FSCTL_ENCRYPTION_KEY_CONTROL: u32 = 590852u32;
2962 pub const FSCTL_ENUM_EXTERNAL_BACKING: u32 = 590616u32;
2963 pub const FSCTL_ENUM_OVERLAY: u32 = 590623u32;
2964 pub const FSCTL_ENUM_USN_DATA: u32 = 590003u32;
2965 pub const FSCTL_EXTEND_VOLUME: u32 = 590064u32;
2966 pub const FSCTL_FILESYSTEM_GET_STATISTICS: u32 = 589920u32;
2967 pub const FSCTL_FILESYSTEM_GET_STATISTICS_EX: u32 = 590732u32;
2968 pub const FSCTL_FILE_LEVEL_TRIM: u32 = 623112u32;
2969 pub const FSCTL_FILE_PREFETCH: u32 = 590112u32;
2970 pub const FSCTL_FILE_TYPE_NOTIFICATION: u32 = 590340u32;
2971 pub const FSCTL_FIND_FILES_BY_SID: u32 = 589967u32;
2972 pub const FSCTL_GET_BOOT_AREA_INFO: u32 = 590384u32;
2973 pub const FSCTL_GET_COMPRESSION: u32 = 589884u32;
2974 pub const FSCTL_GET_EXTERNAL_BACKING: u32 = 590608u32;
2975 pub const FSCTL_GET_FILTER_FILE_IDENTIFIER: u32 = 590788u32;
2976 pub const FSCTL_GET_INTEGRITY_INFORMATION: u32 = 590460u32;
2977 #[repr(C)]
2978 pub struct FSCTL_GET_INTEGRITY_INFORMATION_BUFFER {
2979     pub ChecksumAlgorithm: u16,
2980     pub Reserved: u16,
2981     pub Flags: u32,
2982     pub ChecksumChunkSizeInBytes: u32,
2983     pub ClusterSizeInBytes: u32,
2984 }
2985 impl ::core::marker::Copy for FSCTL_GET_INTEGRITY_INFORMATION_BUFFER {}
2986 impl ::core::clone::Clone for FSCTL_GET_INTEGRITY_INFORMATION_BUFFER {
2987     fn clone(&self) -> Self {
2988         *self
2989     }
2990 }
2991 pub const FSCTL_GET_NTFS_FILE_RECORD: u32 = 589928u32;
2992 pub const FSCTL_GET_NTFS_VOLUME_DATA: u32 = 589924u32;
2993 pub const FSCTL_GET_OBJECT_ID: u32 = 589980u32;
2994 pub const FSCTL_GET_REFS_VOLUME_DATA: u32 = 590552u32;
2995 pub const FSCTL_GET_REPAIR: u32 = 590236u32;
2996 pub const FSCTL_GET_REPARSE_POINT: u32 = 589992u32;
2997 pub const FSCTL_GET_RETRIEVAL_POINTERS: u32 = 589939u32;
2998 pub const FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT: u32 = 590803u32;
2999 pub const FSCTL_GET_RETRIEVAL_POINTER_BASE: u32 = 590388u32;
3000 pub const FSCTL_GET_RETRIEVAL_POINTER_COUNT: u32 = 590891u32;
3001 pub const FSCTL_GET_VOLUME_BITMAP: u32 = 589935u32;
3002 pub const FSCTL_GET_WOF_VERSION: u32 = 590696u32;
3003 pub const FSCTL_GHOST_FILE_EXTENTS: u32 = 623532u32;
3004 pub const FSCTL_HCS_ASYNC_TUNNEL_REQUEST: u32 = 590704u32;
3005 pub const FSCTL_HCS_SYNC_NO_WRITE_TUNNEL_REQUEST: u32 = 590776u32;
3006 pub const FSCTL_HCS_SYNC_TUNNEL_REQUEST: u32 = 590700u32;
3007 pub const FSCTL_INITIATE_FILE_METADATA_OPTIMIZATION: u32 = 590684u32;
3008 pub const FSCTL_INITIATE_REPAIR: u32 = 590248u32;
3009 pub const FSCTL_INTEGRITY_FLAG_CHECKSUM_ENFORCEMENT_OFF: u32 = 1u32;
3010 pub const FSCTL_INVALIDATE_VOLUMES: u32 = 589908u32;
3011 pub const FSCTL_IS_CSV_FILE: u32 = 590408u32;
3012 pub const FSCTL_IS_FILE_ON_CSV_VOLUME: u32 = 590428u32;
3013 pub const FSCTL_IS_PATHNAME_VALID: u32 = 589868u32;
3014 pub const FSCTL_IS_VOLUME_DIRTY: u32 = 589944u32;
3015 pub const FSCTL_IS_VOLUME_MOUNTED: u32 = 589864u32;
3016 pub const FSCTL_IS_VOLUME_OWNED_BYCSVFS: u32 = 590456u32;
3017 pub const FSCTL_LOCK_VOLUME: u32 = 589848u32;
3018 pub const FSCTL_LOOKUP_STREAM_FROM_CLUSTER: u32 = 590332u32;
3019 pub const FSCTL_MAKE_MEDIA_COMPATIBLE: u32 = 622896u32;
3020 pub const FSCTL_MANAGE_BYPASS_IO: u32 = 590920u32;
3021 pub const FSCTL_MARK_AS_SYSTEM_HIVE: u32 = 589903u32;
3022 pub const FSCTL_MARK_HANDLE: u32 = 590076u32;
3023 pub const FSCTL_MARK_VOLUME_DIRTY: u32 = 589872u32;
3024 pub const FSCTL_MOVE_FILE: u32 = 589940u32;
3025 pub const FSCTL_NOTIFY_DATA_CHANGE: u32 = 590844u32;
3026 pub const FSCTL_NOTIFY_STORAGE_SPACE_ALLOCATION: u32 = 590748u32;
3027 pub const FSCTL_OFFLOAD_READ: u32 = 606820u32;
3028 #[repr(C)]
3029 pub struct FSCTL_OFFLOAD_READ_INPUT {
3030     pub Size: u32,
3031     pub Flags: u32,
3032     pub TokenTimeToLive: u32,
3033     pub Reserved: u32,
3034     pub FileOffset: u64,
3035     pub CopyLength: u64,
3036 }
3037 impl ::core::marker::Copy for FSCTL_OFFLOAD_READ_INPUT {}
3038 impl ::core::clone::Clone for FSCTL_OFFLOAD_READ_INPUT {
3039     fn clone(&self) -> Self {
3040         *self
3041     }
3042 }
3043 #[repr(C)]
3044 pub struct FSCTL_OFFLOAD_READ_OUTPUT {
3045     pub Size: u32,
3046     pub Flags: u32,
3047     pub TransferLength: u64,
3048     pub Token: [u8; 512],
3049 }
3050 impl ::core::marker::Copy for FSCTL_OFFLOAD_READ_OUTPUT {}
3051 impl ::core::clone::Clone for FSCTL_OFFLOAD_READ_OUTPUT {
3052     fn clone(&self) -> Self {
3053         *self
3054     }
3055 }
3056 pub const FSCTL_OFFLOAD_WRITE: u32 = 623208u32;
3057 #[repr(C)]
3058 pub struct FSCTL_OFFLOAD_WRITE_INPUT {
3059     pub Size: u32,
3060     pub Flags: u32,
3061     pub FileOffset: u64,
3062     pub CopyLength: u64,
3063     pub TransferOffset: u64,
3064     pub Token: [u8; 512],
3065 }
3066 impl ::core::marker::Copy for FSCTL_OFFLOAD_WRITE_INPUT {}
3067 impl ::core::clone::Clone for FSCTL_OFFLOAD_WRITE_INPUT {
3068     fn clone(&self) -> Self {
3069         *self
3070     }
3071 }
3072 #[repr(C)]
3073 pub struct FSCTL_OFFLOAD_WRITE_OUTPUT {
3074     pub Size: u32,
3075     pub Flags: u32,
3076     pub LengthWritten: u64,
3077 }
3078 impl ::core::marker::Copy for FSCTL_OFFLOAD_WRITE_OUTPUT {}
3079 impl ::core::clone::Clone for FSCTL_OFFLOAD_WRITE_OUTPUT {
3080     fn clone(&self) -> Self {
3081         *self
3082     }
3083 }
3084 pub const FSCTL_OPBATCH_ACK_CLOSE_PENDING: u32 = 589840u32;
3085 pub const FSCTL_OPLOCK_BREAK_ACKNOWLEDGE: u32 = 589836u32;
3086 pub const FSCTL_OPLOCK_BREAK_ACK_NO_2: u32 = 589904u32;
3087 pub const FSCTL_OPLOCK_BREAK_NOTIFY: u32 = 589844u32;
3088 pub const FSCTL_QUERY_ALLOCATED_RANGES: u32 = 606415u32;
3089 pub const FSCTL_QUERY_ASYNC_DUPLICATE_EXTENTS_STATUS: u32 = 590896u32;
3090 pub const FSCTL_QUERY_BAD_RANGES: u32 = 590828u32;
3091 pub const FSCTL_QUERY_DEPENDENT_VOLUME: u32 = 590320u32;
3092 pub const FSCTL_QUERY_DIRECT_ACCESS_EXTENTS: u32 = 590747u32;
3093 pub const FSCTL_QUERY_DIRECT_IMAGE_ORIGINAL_BASE: u32 = 590756u32;
3094 pub const FSCTL_QUERY_EXTENT_READ_CACHE_INFO: u32 = 590711u32;
3095 pub const FSCTL_QUERY_FAT_BPB: u32 = 589912u32;
3096 #[repr(C)]
3097 pub struct FSCTL_QUERY_FAT_BPB_BUFFER {
3098     pub First0x24BytesOfBootSector: [u8; 36],
3099 }
3100 impl ::core::marker::Copy for FSCTL_QUERY_FAT_BPB_BUFFER {}
3101 impl ::core::clone::Clone for FSCTL_QUERY_FAT_BPB_BUFFER {
3102     fn clone(&self) -> Self {
3103         *self
3104     }
3105 }
3106 pub const FSCTL_QUERY_FILE_LAYOUT: u32 = 590455u32;
3107 pub const FSCTL_QUERY_FILE_METADATA_OPTIMIZATION: u32 = 590688u32;
3108 pub const FSCTL_QUERY_FILE_REGIONS: u32 = 590468u32;
3109 pub const FSCTL_QUERY_FILE_SYSTEM_RECOGNITION: u32 = 590412u32;
3110 pub const FSCTL_QUERY_GHOSTED_FILE_EXTENTS: u32 = 590768u32;
3111 pub const FSCTL_QUERY_ON_DISK_VOLUME_INFO: u32 = 590140u32;
3112 pub const FSCTL_QUERY_PAGEFILE_ENCRYPTION: u32 = 590312u32;
3113 pub const FSCTL_QUERY_PERSISTENT_VOLUME_STATE: u32 = 590396u32;
3114 pub const FSCTL_QUERY_REFS_SMR_VOLUME_INFO: u32 = 590812u32;
3115 pub const FSCTL_QUERY_REFS_VOLUME_COUNTER_INFO: u32 = 590715u32;
3116 pub const FSCTL_QUERY_REGION_INFO: u32 = 590576u32;
3117 #[repr(C)]
3118 pub struct FSCTL_QUERY_REGION_INFO_INPUT {
3119     pub Version: u32,
3120     pub Size: u32,
3121     pub Flags: u32,
3122     pub NumberOfTierIds: u32,
3123     pub TierIds: [::windows_sys::core::GUID; 1],
3124 }
3125 impl ::core::marker::Copy for FSCTL_QUERY_REGION_INFO_INPUT {}
3126 impl ::core::clone::Clone for FSCTL_QUERY_REGION_INFO_INPUT {
3127     fn clone(&self) -> Self {
3128         *self
3129     }
3130 }
3131 #[repr(C)]
3132 pub struct FSCTL_QUERY_REGION_INFO_OUTPUT {
3133     pub Version: u32,
3134     pub Size: u32,
3135     pub Flags: u32,
3136     pub Reserved: u32,
3137     pub Alignment: u64,
3138     pub TotalNumberOfRegions: u32,
3139     pub NumberOfRegionsReturned: u32,
3140     pub Regions: [FILE_STORAGE_TIER_REGION; 1],
3141 }
3142 impl ::core::marker::Copy for FSCTL_QUERY_REGION_INFO_OUTPUT {}
3143 impl ::core::clone::Clone for FSCTL_QUERY_REGION_INFO_OUTPUT {
3144     fn clone(&self) -> Self {
3145         *self
3146     }
3147 }
3148 pub const FSCTL_QUERY_RETRIEVAL_POINTERS: u32 = 589883u32;
3149 pub const FSCTL_QUERY_SHARED_VIRTUAL_DISK_SUPPORT: u32 = 590592u32;
3150 pub const FSCTL_QUERY_SPARING_INFO: u32 = 590136u32;
3151 pub const FSCTL_QUERY_STORAGE_CLASSES: u32 = 590572u32;
3152 #[repr(C)]
3153 pub struct FSCTL_QUERY_STORAGE_CLASSES_OUTPUT {
3154     pub Version: u32,
3155     pub Size: u32,
3156     pub Flags: FILE_STORAGE_TIER_FLAGS,
3157     pub TotalNumberOfTiers: u32,
3158     pub NumberOfTiersReturned: u32,
3159     pub Tiers: [FILE_STORAGE_TIER; 1],
3160 }
3161 impl ::core::marker::Copy for FSCTL_QUERY_STORAGE_CLASSES_OUTPUT {}
3162 impl ::core::clone::Clone for FSCTL_QUERY_STORAGE_CLASSES_OUTPUT {
3163     fn clone(&self) -> Self {
3164         *self
3165     }
3166 }
3167 pub const FSCTL_QUERY_USN_JOURNAL: u32 = 590068u32;
3168 pub const FSCTL_QUERY_VOLUME_CONTAINER_STATE: u32 = 590736u32;
3169 pub const FSCTL_QUERY_VOLUME_NUMA_INFO: u32 = 590804u32;
3170 pub const FSCTL_READ_FILE_USN_DATA: u32 = 590059u32;
3171 pub const FSCTL_READ_FROM_PLEX: u32 = 606494u32;
3172 pub const FSCTL_READ_RAW_ENCRYPTED: u32 = 590051u32;
3173 pub const FSCTL_READ_UNPRIVILEGED_USN_JOURNAL: u32 = 590763u32;
3174 pub const FSCTL_READ_USN_JOURNAL: u32 = 590011u32;
3175 pub const FSCTL_REARRANGE_FILE: u32 = 640032u32;
3176 pub const FSCTL_RECALL_FILE: u32 = 590103u32;
3177 pub const FSCTL_REFS_DEALLOCATE_RANGES: u32 = 590808u32;
3178 pub const FSCTL_REFS_STREAM_SNAPSHOT_MANAGEMENT: u32 = 590912u32;
3179 pub const FSCTL_REMOVE_OVERLAY: u32 = 623412u32;
3180 pub const FSCTL_REPAIR_COPIES: u32 = 639668u32;
3181 pub const FSCTL_REQUEST_BATCH_OPLOCK: u32 = 589832u32;
3182 pub const FSCTL_REQUEST_FILTER_OPLOCK: u32 = 589916u32;
3183 pub const FSCTL_REQUEST_OPLOCK: u32 = 590400u32;
3184 pub const FSCTL_REQUEST_OPLOCK_LEVEL_1: u32 = 589824u32;
3185 pub const FSCTL_REQUEST_OPLOCK_LEVEL_2: u32 = 589828u32;
3186 pub const FSCTL_RESET_VOLUME_ALLOCATION_HINTS: u32 = 590316u32;
3187 pub const FSCTL_RKF_INTERNAL: u32 = 590511u32;
3188 pub const FSCTL_SCRUB_DATA: u32 = 590512u32;
3189 pub const FSCTL_SCRUB_UNDISCOVERABLE_ID: u32 = 590840u32;
3190 pub const FSCTL_SD_GLOBAL_CHANGE: u32 = 590324u32;
3191 pub const FSCTL_SECURITY_ID_CHECK: u32 = 606391u32;
3192 pub const FSCTL_SET_BOOTLOADER_ACCESSED: u32 = 589903u32;
3193 pub const FSCTL_SET_COMPRESSION: u32 = 639040u32;
3194 pub const FSCTL_SET_DAX_ALLOC_ALIGNMENT_HINT: u32 = 590832u32;
3195 pub const FSCTL_SET_DEFECT_MANAGEMENT: u32 = 622900u32;
3196 pub const FSCTL_SET_ENCRYPTION: u32 = 590039u32;
3197 pub const FSCTL_SET_EXTERNAL_BACKING: u32 = 590604u32;
3198 pub const FSCTL_SET_INTEGRITY_INFORMATION: u32 = 639616u32;
3199 #[repr(C)]
3200 pub struct FSCTL_SET_INTEGRITY_INFORMATION_BUFFER {
3201     pub ChecksumAlgorithm: u16,
3202     pub Reserved: u16,
3203     pub Flags: u32,
3204 }
3205 impl ::core::marker::Copy for FSCTL_SET_INTEGRITY_INFORMATION_BUFFER {}
3206 impl ::core::clone::Clone for FSCTL_SET_INTEGRITY_INFORMATION_BUFFER {
3207     fn clone(&self) -> Self {
3208         *self
3209     }
3210 }
3211 #[repr(C)]
3212 pub struct FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX {
3213     pub EnableIntegrity: u8,
3214     pub KeepIntegrityStateUnchanged: u8,
3215     pub Reserved: u16,
3216     pub Flags: u32,
3217     pub Version: u8,
3218     pub Reserved2: [u8; 7],
3219 }
3220 impl ::core::marker::Copy for FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX {}
3221 impl ::core::clone::Clone for FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX {
3222     fn clone(&self) -> Self {
3223         *self
3224     }
3225 }
3226 pub const FSCTL_SET_INTEGRITY_INFORMATION_EX: u32 = 590720u32;
3227 pub const FSCTL_SET_LAYER_ROOT: u32 = 590740u32;
3228 pub const FSCTL_SET_OBJECT_ID: u32 = 589976u32;
3229 pub const FSCTL_SET_OBJECT_ID_EXTENDED: u32 = 590012u32;
3230 pub const FSCTL_SET_PERSISTENT_VOLUME_STATE: u32 = 590392u32;
3231 pub const FSCTL_SET_PURGE_FAILURE_MODE: u32 = 590448u32;
3232 pub const FSCTL_SET_REFS_FILE_STRICTLY_SEQUENTIAL: u32 = 590820u32;
3233 pub const FSCTL_SET_REFS_SMR_VOLUME_GC_PARAMETERS: u32 = 590816u32;
3234 pub const FSCTL_SET_REPAIR: u32 = 590232u32;
3235 pub const FSCTL_SET_REPARSE_POINT: u32 = 589988u32;
3236 pub const FSCTL_SET_REPARSE_POINT_EX: u32 = 590860u32;
3237 pub const FSCTL_SET_SHORT_NAME_BEHAVIOR: u32 = 590260u32;
3238 pub const FSCTL_SET_SPARSE: u32 = 590020u32;
3239 pub const FSCTL_SET_VOLUME_COMPRESSION_STATE: u32 = 590144u32;
3240 pub const FSCTL_SET_ZERO_DATA: u32 = 622792u32;
3241 pub const FSCTL_SET_ZERO_ON_DEALLOCATION: u32 = 590228u32;
3242 pub const FSCTL_SHRINK_VOLUME: u32 = 590256u32;
3243 pub const FSCTL_SHUFFLE_FILE: u32 = 639808u32;
3244 pub const FSCTL_SIS_COPYFILE: u32 = 590080u32;
3245 pub const FSCTL_SIS_LINK_FILES: u32 = 639236u32;
3246 pub const FSCTL_SMB_SHARE_FLUSH_AND_PURGE: u32 = 590908u32;
3247 pub const FSCTL_SPARSE_OVERALLOCATE: u32 = 590668u32;
3248 pub const FSCTL_SSDI_STORAGE_REQUEST: u32 = 590752u32;
3249 pub const FSCTL_START_VIRTUALIZATION_INSTANCE: u32 = 590784u32;
3250 pub const FSCTL_START_VIRTUALIZATION_INSTANCE_EX: u32 = 590848u32;
3251 pub const FSCTL_STORAGE_QOS_CONTROL: u32 = 590672u32;
3252 pub const FSCTL_STREAMS_ASSOCIATE_ID: u32 = 590792u32;
3253 pub const FSCTL_STREAMS_QUERY_ID: u32 = 590796u32;
3254 pub const FSCTL_STREAMS_QUERY_PARAMETERS: u32 = 590788u32;
3255 pub const FSCTL_SUSPEND_OVERLAY: u32 = 590724u32;
3256 pub const FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST: u32 = 590692u32;
3257 pub const FSCTL_SVHDX_SET_INITIATOR_INFORMATION: u32 = 590600u32;
3258 pub const FSCTL_SVHDX_SYNC_TUNNEL_REQUEST: u32 = 590596u32;
3259 pub const FSCTL_TXFS_CREATE_MINIVERSION: u32 = 622972u32;
3260 pub const FSCTL_TXFS_CREATE_SECONDARY_RM: u32 = 622952u32;
3261 pub const FSCTL_TXFS_GET_METADATA_INFO: u32 = 606572u32;
3262 pub const FSCTL_TXFS_GET_TRANSACTED_VERSION: u32 = 606576u32;
3263 pub const FSCTL_TXFS_LIST_TRANSACTIONS: u32 = 606692u32;
3264 pub const FSCTL_TXFS_LIST_TRANSACTION_LOCKED_FILES: u32 = 606688u32;
3265 pub const FSCTL_TXFS_MODIFY_RM: u32 = 622916u32;
3266 pub const FSCTL_TXFS_QUERY_RM_INFORMATION: u32 = 606536u32;
3267 pub const FSCTL_TXFS_READ_BACKUP_INFORMATION: u32 = 606560u32;
3268 pub const FSCTL_TXFS_READ_BACKUP_INFORMATION2: u32 = 590328u32;
3269 pub const FSCTL_TXFS_ROLLFORWARD_REDO: u32 = 622928u32;
3270 pub const FSCTL_TXFS_ROLLFORWARD_UNDO: u32 = 622932u32;
3271 pub const FSCTL_TXFS_SAVEPOINT_INFORMATION: u32 = 622968u32;
3272 pub const FSCTL_TXFS_SHUTDOWN_RM: u32 = 622940u32;
3273 pub const FSCTL_TXFS_START_RM: u32 = 622936u32;
3274 pub const FSCTL_TXFS_TRANSACTION_ACTIVE: u32 = 606604u32;
3275 pub const FSCTL_TXFS_WRITE_BACKUP_INFORMATION: u32 = 622948u32;
3276 pub const FSCTL_TXFS_WRITE_BACKUP_INFORMATION2: u32 = 590336u32;
3277 pub const FSCTL_UNLOCK_VOLUME: u32 = 589852u32;
3278 pub const FSCTL_UNMAP_SPACE: u32 = 590772u32;
3279 pub const FSCTL_UPDATE_OVERLAY: u32 = 623416u32;
3280 pub const FSCTL_USN_TRACK_MODIFIED_RANGES: u32 = 590580u32;
3281 pub const FSCTL_VIRTUAL_STORAGE_PASSTHROUGH: u32 = 590884u32;
3282 pub const FSCTL_VIRTUAL_STORAGE_QUERY_PROPERTY: u32 = 590728u32;
3283 pub const FSCTL_VIRTUAL_STORAGE_SET_BEHAVIOR: u32 = 590856u32;
3284 pub const FSCTL_WAIT_FOR_REPAIR: u32 = 590240u32;
3285 pub const FSCTL_WRITE_RAW_ENCRYPTED: u32 = 590047u32;
3286 pub const FSCTL_WRITE_USN_CLOSE_RECORD: u32 = 590063u32;
3287 pub const FSCTL_WRITE_USN_REASON: u32 = 590544u32;
3288 pub type FS_BPIO_INFLAGS = i32;
3289 pub const FSBPIO_INFL_None: FS_BPIO_INFLAGS = 0i32;
3290 pub const FSBPIO_INFL_SKIP_STORAGE_STACK_QUERY: FS_BPIO_INFLAGS = 1i32;
3291 #[repr(C)]
3292 pub struct FS_BPIO_INFO {
3293     pub ActiveBypassIoCount: u32,
3294     pub StorageDriverNameLen: u16,
3295     pub StorageDriverName: [u16; 32],
3296 }
3297 impl ::core::marker::Copy for FS_BPIO_INFO {}
3298 impl ::core::clone::Clone for FS_BPIO_INFO {
3299     fn clone(&self) -> Self {
3300         *self
3301     }
3302 }
3303 #[repr(C)]
3304 pub struct FS_BPIO_INPUT {
3305     pub Operation: FS_BPIO_OPERATIONS,
3306     pub InFlags: FS_BPIO_INFLAGS,
3307     pub Reserved1: u64,
3308     pub Reserved2: u64,
3309 }
3310 impl ::core::marker::Copy for FS_BPIO_INPUT {}
3311 impl ::core::clone::Clone for FS_BPIO_INPUT {
3312     fn clone(&self) -> Self {
3313         *self
3314     }
3315 }
3316 pub type FS_BPIO_OPERATIONS = i32;
3317 pub const FS_BPIO_OP_ENABLE: FS_BPIO_OPERATIONS = 1i32;
3318 pub const FS_BPIO_OP_DISABLE: FS_BPIO_OPERATIONS = 2i32;
3319 pub const FS_BPIO_OP_QUERY: FS_BPIO_OPERATIONS = 3i32;
3320 pub const FS_BPIO_OP_VOLUME_STACK_PAUSE: FS_BPIO_OPERATIONS = 4i32;
3321 pub const FS_BPIO_OP_VOLUME_STACK_RESUME: FS_BPIO_OPERATIONS = 5i32;
3322 pub const FS_BPIO_OP_STREAM_PAUSE: FS_BPIO_OPERATIONS = 6i32;
3323 pub const FS_BPIO_OP_STREAM_RESUME: FS_BPIO_OPERATIONS = 7i32;
3324 pub const FS_BPIO_OP_GET_INFO: FS_BPIO_OPERATIONS = 8i32;
3325 pub const FS_BPIO_OP_MAX_OPERATION: FS_BPIO_OPERATIONS = 9i32;
3326 pub type FS_BPIO_OUTFLAGS = i32;
3327 pub const FSBPIO_OUTFL_None: FS_BPIO_OUTFLAGS = 0i32;
3328 pub const FSBPIO_OUTFL_VOLUME_STACK_BYPASS_PAUSED: FS_BPIO_OUTFLAGS = 1i32;
3329 pub const FSBPIO_OUTFL_STREAM_BYPASS_PAUSED: FS_BPIO_OUTFLAGS = 2i32;
3330 pub const FSBPIO_OUTFL_FILTER_ATTACH_BLOCKED: FS_BPIO_OUTFLAGS = 4i32;
3331 pub const FSBPIO_OUTFL_COMPATIBLE_STORAGE_DRIVER: FS_BPIO_OUTFLAGS = 8i32;
3332 #[repr(C)]
3333 pub struct FS_BPIO_OUTPUT {
3334     pub Operation: FS_BPIO_OPERATIONS,
3335     pub OutFlags: FS_BPIO_OUTFLAGS,
3336     pub Reserved1: u64,
3337     pub Reserved2: u64,
3338     pub Anonymous: FS_BPIO_OUTPUT_0,
3339 }
3340 impl ::core::marker::Copy for FS_BPIO_OUTPUT {}
3341 impl ::core::clone::Clone for FS_BPIO_OUTPUT {
3342     fn clone(&self) -> Self {
3343         *self
3344     }
3345 }
3346 #[repr(C)]
3347 pub union FS_BPIO_OUTPUT_0 {
3348     pub Enable: FS_BPIO_RESULTS,
3349     pub Query: FS_BPIO_RESULTS,
3350     pub VolumeStackResume: FS_BPIO_RESULTS,
3351     pub StreamResume: FS_BPIO_RESULTS,
3352     pub GetInfo: FS_BPIO_INFO,
3353 }
3354 impl ::core::marker::Copy for FS_BPIO_OUTPUT_0 {}
3355 impl ::core::clone::Clone for FS_BPIO_OUTPUT_0 {
3356     fn clone(&self) -> Self {
3357         *self
3358     }
3359 }
3360 #[repr(C)]
3361 pub struct FS_BPIO_RESULTS {
3362     pub OpStatus: u32,
3363     pub FailingDriverNameLen: u16,
3364     pub FailingDriverName: [u16; 32],
3365     pub FailureReasonLen: u16,
3366     pub FailureReason: [u16; 128],
3367 }
3368 impl ::core::marker::Copy for FS_BPIO_RESULTS {}
3369 impl ::core::clone::Clone for FS_BPIO_RESULTS {
3370     fn clone(&self) -> Self {
3371         *self
3372     }
3373 }
3374 pub const FW_ISSUEID_NO_ISSUE: u32 = 0u32;
3375 pub const FW_ISSUEID_UNKNOWN: u32 = 4294967295u32;
3376 #[repr(C, packed(1))]
3377 pub struct GETVERSIONINPARAMS {
3378     pub bVersion: u8,
3379     pub bRevision: u8,
3380     pub bReserved: u8,
3381     pub bIDEDeviceMap: u8,
3382     pub fCapabilities: u32,
3383     pub dwReserved: [u32; 4],
3384 }
3385 impl ::core::marker::Copy for GETVERSIONINPARAMS {}
3386 impl ::core::clone::Clone for GETVERSIONINPARAMS {
3387     fn clone(&self) -> Self {
3388         *self
3389     }
3390 }
3391 #[repr(C)]
3392 pub struct GET_CHANGER_PARAMETERS {
3393     pub Size: u32,
3394     pub NumberTransportElements: u16,
3395     pub NumberStorageElements: u16,
3396     pub NumberCleanerSlots: u16,
3397     pub NumberIEElements: u16,
3398     pub NumberDataTransferElements: u16,
3399     pub NumberOfDoors: u16,
3400     pub FirstSlotNumber: u16,
3401     pub FirstDriveNumber: u16,
3402     pub FirstTransportNumber: u16,
3403     pub FirstIEPortNumber: u16,
3404     pub FirstCleanerSlotAddress: u16,
3405     pub MagazineSize: u16,
3406     pub DriveCleanTimeout: u32,
3407     pub Features0: CHANGER_FEATURES,
3408     pub Features1: GET_CHANGER_PARAMETERS_FEATURES1,
3409     pub MoveFromTransport: u8,
3410     pub MoveFromSlot: u8,
3411     pub MoveFromIePort: u8,
3412     pub MoveFromDrive: u8,
3413     pub ExchangeFromTransport: u8,
3414     pub ExchangeFromSlot: u8,
3415     pub ExchangeFromIePort: u8,
3416     pub ExchangeFromDrive: u8,
3417     pub LockUnlockCapabilities: u8,
3418     pub PositionCapabilities: u8,
3419     pub Reserved1: [u8; 2],
3420     pub Reserved2: [u32; 2],
3421 }
3422 impl ::core::marker::Copy for GET_CHANGER_PARAMETERS {}
3423 impl ::core::clone::Clone for GET_CHANGER_PARAMETERS {
3424     fn clone(&self) -> Self {
3425         *self
3426     }
3427 }
3428 pub type GET_CHANGER_PARAMETERS_FEATURES1 = u32;
3429 pub const CHANGER_CLEANER_AUTODISMOUNT: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483652u32;
3430 pub const CHANGER_CLEANER_OPS_NOT_SUPPORTED: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483712u32;
3431 pub const CHANGER_IEPORT_USER_CONTROL_CLOSE: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483904u32;
3432 pub const CHANGER_IEPORT_USER_CONTROL_OPEN: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483776u32;
3433 pub const CHANGER_MOVE_EXTENDS_IEPORT: GET_CHANGER_PARAMETERS_FEATURES1 = 2147484160u32;
3434 pub const CHANGER_MOVE_RETRACTS_IEPORT: GET_CHANGER_PARAMETERS_FEATURES1 = 2147484672u32;
3435 pub const CHANGER_PREDISMOUNT_ALIGN_TO_DRIVE: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483650u32;
3436 pub const CHANGER_PREDISMOUNT_ALIGN_TO_SLOT: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483649u32;
3437 pub const CHANGER_RTN_MEDIA_TO_ORIGINAL_ADDR: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483680u32;
3438 pub const CHANGER_SLOTS_USE_TRAYS: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483664u32;
3439 pub const CHANGER_TRUE_EXCHANGE_CAPABLE: GET_CHANGER_PARAMETERS_FEATURES1 = 2147483656u32;
3440 #[repr(C)]
3441 pub struct GET_DEVICE_INTERNAL_STATUS_DATA_REQUEST {
3442     pub Version: u32,
3443     pub Size: u32,
3444     pub RequestDataType: DEVICE_INTERNAL_STATUS_DATA_REQUEST_TYPE,
3445     pub RequestDataSet: DEVICE_INTERNAL_STATUS_DATA_SET,
3446 }
3447 impl ::core::marker::Copy for GET_DEVICE_INTERNAL_STATUS_DATA_REQUEST {}
3448 impl ::core::clone::Clone for GET_DEVICE_INTERNAL_STATUS_DATA_REQUEST {
3449     fn clone(&self) -> Self {
3450         *self
3451     }
3452 }
3453 #[repr(C)]
3454 pub struct GET_DISK_ATTRIBUTES {
3455     pub Version: u32,
3456     pub Reserved1: u32,
3457     pub Attributes: u64,
3458 }
3459 impl ::core::marker::Copy for GET_DISK_ATTRIBUTES {}
3460 impl ::core::clone::Clone for GET_DISK_ATTRIBUTES {
3461     fn clone(&self) -> Self {
3462         *self
3463     }
3464 }
3465 #[repr(C)]
3466 pub struct GET_FILTER_FILE_IDENTIFIER_INPUT {
3467     pub AltitudeLength: u16,
3468     pub Altitude: [u16; 1],
3469 }
3470 impl ::core::marker::Copy for GET_FILTER_FILE_IDENTIFIER_INPUT {}
3471 impl ::core::clone::Clone for GET_FILTER_FILE_IDENTIFIER_INPUT {
3472     fn clone(&self) -> Self {
3473         *self
3474     }
3475 }
3476 #[repr(C)]
3477 pub struct GET_FILTER_FILE_IDENTIFIER_OUTPUT {
3478     pub FilterFileIdentifierLength: u16,
3479     pub FilterFileIdentifier: [u8; 1],
3480 }
3481 impl ::core::marker::Copy for GET_FILTER_FILE_IDENTIFIER_OUTPUT {}
3482 impl ::core::clone::Clone for GET_FILTER_FILE_IDENTIFIER_OUTPUT {
3483     fn clone(&self) -> Self {
3484         *self
3485     }
3486 }
3487 #[repr(C)]
3488 pub struct GET_LENGTH_INFORMATION {
3489     pub Length: i64,
3490 }
3491 impl ::core::marker::Copy for GET_LENGTH_INFORMATION {}
3492 impl ::core::clone::Clone for GET_LENGTH_INFORMATION {
3493     fn clone(&self) -> Self {
3494         *self
3495     }
3496 }
3497 #[repr(C)]
3498 #[cfg(feature = "Win32_Storage_FileSystem")]
3499 pub struct GET_MEDIA_TYPES {
3500     pub DeviceType: u32,
3501     pub MediaInfoCount: u32,
3502     pub MediaInfo: [DEVICE_MEDIA_INFO; 1],
3503 }
3504 #[cfg(feature = "Win32_Storage_FileSystem")]
3505 impl ::core::marker::Copy for GET_MEDIA_TYPES {}
3506 #[cfg(feature = "Win32_Storage_FileSystem")]
3507 impl ::core::clone::Clone for GET_MEDIA_TYPES {
3508     fn clone(&self) -> Self {
3509         *self
3510     }
3511 }
3512 pub const GET_VOLUME_BITMAP_FLAG_MASK_METADATA: u32 = 1u32;
3513 pub type GPT_ATTRIBUTES = u64;
3514 pub const GPT_ATTRIBUTE_PLATFORM_REQUIRED: GPT_ATTRIBUTES = 1u64;
3515 pub const GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER: GPT_ATTRIBUTES = 9223372036854775808u64;
3516 pub const GPT_BASIC_DATA_ATTRIBUTE_HIDDEN: GPT_ATTRIBUTES = 4611686018427387904u64;
3517 pub const GPT_BASIC_DATA_ATTRIBUTE_SHADOW_COPY: GPT_ATTRIBUTES = 2305843009213693952u64;
3518 pub const GPT_BASIC_DATA_ATTRIBUTE_READ_ONLY: GPT_ATTRIBUTES = 1152921504606846976u64;
3519 pub const GPT_ATTRIBUTE_LEGACY_BIOS_BOOTABLE: u64 = 4u64;
3520 pub const GPT_ATTRIBUTE_NO_BLOCK_IO_PROTOCOL: u64 = 2u64;
3521 pub const GPT_BASIC_DATA_ATTRIBUTE_DAX: u64 = 288230376151711744u64;
3522 pub const GPT_BASIC_DATA_ATTRIBUTE_OFFLINE: u64 = 576460752303423488u64;
3523 pub const GPT_BASIC_DATA_ATTRIBUTE_SERVICE: u64 = 144115188075855872u64;
3524 pub const GPT_SPACES_ATTRIBUTE_NO_METADATA: u64 = 9223372036854775808u64;
3525 #[repr(C, packed(1))]
3526 pub struct GP_LOG_PAGE_DESCRIPTOR {
3527     pub LogAddress: u16,
3528     pub LogSectors: u16,
3529 }
3530 impl ::core::marker::Copy for GP_LOG_PAGE_DESCRIPTOR {}
3531 impl ::core::clone::Clone for GP_LOG_PAGE_DESCRIPTOR {
3532     fn clone(&self) -> Self {
3533         *self
3534     }
3535 }
3536 pub const GUID_DEVICEDUMP_DRIVER_STORAGE_PORT: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3665970205, data2: 28994, data3: 19393, data4: [184, 68, 8, 7, 197, 164, 182, 127] };
3537 pub const GUID_DEVICEDUMP_STORAGE_DEVICE: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3638712623, data2: 6827, data3: 19798, data4: [167, 70, 31, 117, 133, 223, 64, 244] };
3538 pub const GUID_DEVINTERFACE_CDCHANGER: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590610, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3539 pub const GUID_DEVINTERFACE_CDROM: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590600, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3540 pub const GUID_DEVINTERFACE_COMPORT: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 2262880736, data2: 32905, data3: 4560, data4: [156, 228, 8, 0, 62, 48, 31, 115] };
3541 pub const GUID_DEVINTERFACE_DISK: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590599, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3542 pub const GUID_DEVINTERFACE_FLOPPY: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590609, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3543 pub const GUID_DEVINTERFACE_HIDDEN_VOLUME: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
3544     data1: 2131790376,
3545     data2: 38963,
3546     data3: 19259,
3547     data4: [183, 128, 44, 107, 95, 165, 192, 98],
3548 };
3549 pub const GUID_DEVINTERFACE_MEDIUMCHANGER: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590608, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3550 pub const GUID_DEVINTERFACE_PARTITION: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590602, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3551 pub const GUID_DEVINTERFACE_SCM_PHYSICAL_DEVICE: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1115906205, data2: 19906, data3: 17342, data4: [187, 180, 79, 21, 223, 206, 44, 97] };
3552 pub const GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1295444344, data2: 58149, data3: 4558, data4: [191, 193, 8, 0, 43, 225, 3, 24] };
3553 pub const GUID_DEVINTERFACE_SERVICE_VOLUME: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
3554     data1: 1856847234,
3555     data2: 9708,
3556     data3: 18108,
3557     data4: [183, 253, 193, 240, 223, 143, 80, 55],
3558 };
3559 pub const GUID_DEVINTERFACE_SES: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 395364844, data2: 18389, data3: 19955, data4: [181, 175, 154, 223, 60, 242, 62, 72] };
3560 pub const GUID_DEVINTERFACE_STORAGEPORT: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 718077536, data2: 49456, data3: 4562, data4: [176, 130, 0, 160, 201, 30, 251, 139] };
3561 pub const GUID_DEVINTERFACE_TAPE: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590603, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3562 pub const GUID_DEVINTERFACE_UNIFIED_ACCESS_RPMB: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 658799649, data2: 48323, data3: 19719, data4: [160, 91, 163, 57, 91, 180, 238, 231] };
3563 pub const GUID_DEVINTERFACE_VMLUN: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1866556953, data2: 40745, data3: 17061, data4: [178, 11, 55, 226, 25, 202, 2, 176] };
3564 pub const GUID_DEVINTERFACE_VOLUME: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590605, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3565 pub const GUID_DEVINTERFACE_WRITEONCEDISK: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1408590604, data2: 46783, data3: 4560, data4: [148, 242, 0, 160, 201, 30, 251, 139] };
3566 pub const GUID_DEVINTERFACE_ZNSDISK: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3094954437, data2: 65499, data3: 17351, data4: [182, 177, 32, 182, 50, 240, 177, 9] };
3567 pub const GUID_SCM_PD_HEALTH_NOTIFICATION: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 2644693894, data2: 29429, data3: 20195, data4: [129, 85, 236, 160, 103, 142, 59, 6] };
3568 pub const GUID_SCM_PD_PASSTHROUGH_INVDIMM: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1124707376, data2: 3345, data3: 4580, data4: [145, 145, 8, 0, 32, 12, 154, 102] };
3569 #[repr(C)]
3570 pub struct HISTOGRAM_BUCKET {
3571     pub Reads: u32,
3572     pub Writes: u32,
3573 }
3574 impl ::core::marker::Copy for HISTOGRAM_BUCKET {}
3575 impl ::core::clone::Clone for HISTOGRAM_BUCKET {
3576     fn clone(&self) -> Self {
3577         *self
3578     }
3579 }
3580 pub const HIST_NO_OF_BUCKETS: u32 = 24u32;
3581 pub const IDENTIFY_BUFFER_SIZE: u32 = 512u32;
3582 #[repr(C)]
3583 pub struct IDEREGS {
3584     pub bFeaturesReg: u8,
3585     pub bSectorCountReg: u8,
3586     pub bSectorNumberReg: u8,
3587     pub bCylLowReg: u8,
3588     pub bCylHighReg: u8,
3589     pub bDriveHeadReg: u8,
3590     pub bCommandReg: u8,
3591     pub bReserved: u8,
3592 }
3593 impl ::core::marker::Copy for IDEREGS {}
3594 impl ::core::clone::Clone for IDEREGS {
3595     fn clone(&self) -> Self {
3596         *self
3597     }
3598 }
3599 pub const ID_CMD: u32 = 236u32;
3600 pub const IOCTL_CHANGER_BASE: u32 = 48u32;
3601 pub const IOCTL_CHANGER_EXCHANGE_MEDIUM: u32 = 3162144u32;
3602 pub const IOCTL_CHANGER_GET_ELEMENT_STATUS: u32 = 3194900u32;
3603 pub const IOCTL_CHANGER_GET_PARAMETERS: u32 = 3162112u32;
3604 pub const IOCTL_CHANGER_GET_PRODUCT_DATA: u32 = 3162120u32;
3605 pub const IOCTL_CHANGER_GET_STATUS: u32 = 3162116u32;
3606 pub const IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS: u32 = 3162136u32;
3607 pub const IOCTL_CHANGER_MOVE_MEDIUM: u32 = 3162148u32;
3608 pub const IOCTL_CHANGER_QUERY_VOLUME_TAGS: u32 = 3194924u32;
3609 pub const IOCTL_CHANGER_REINITIALIZE_TRANSPORT: u32 = 3162152u32;
3610 pub const IOCTL_CHANGER_SET_ACCESS: u32 = 3194896u32;
3611 pub const IOCTL_CHANGER_SET_POSITION: u32 = 3162140u32;
3612 pub const IOCTL_DISK_BASE: u32 = 7u32;
3613 pub const IOCTL_DISK_CHECK_VERIFY: u32 = 477184u32;
3614 pub const IOCTL_DISK_CONTROLLER_NUMBER: u32 = 458820u32;
3615 pub const IOCTL_DISK_CREATE_DISK: u32 = 507992u32;
3616 pub const IOCTL_DISK_DELETE_DRIVE_LAYOUT: u32 = 508160u32;
3617 pub const IOCTL_DISK_EJECT_MEDIA: u32 = 477192u32;
3618 pub const IOCTL_DISK_FIND_NEW_DEVICES: u32 = 477208u32;
3619 pub const IOCTL_DISK_FORMAT_DRIVE: u32 = 508876u32;
3620 pub const IOCTL_DISK_FORMAT_TRACKS: u32 = 507928u32;
3621 pub const IOCTL_DISK_FORMAT_TRACKS_EX: u32 = 507948u32;
3622 pub const IOCTL_DISK_GET_CACHE_INFORMATION: u32 = 475348u32;
3623 pub const IOCTL_DISK_GET_DISK_ATTRIBUTES: u32 = 458992u32;
3624 pub const IOCTL_DISK_GET_DRIVE_GEOMETRY: u32 = 458752u32;
3625 pub const IOCTL_DISK_GET_DRIVE_GEOMETRY_EX: u32 = 458912u32;
3626 pub const IOCTL_DISK_GET_DRIVE_LAYOUT: u32 = 475148u32;
3627 pub const IOCTL_DISK_GET_DRIVE_LAYOUT_EX: u32 = 458832u32;
3628 pub const IOCTL_DISK_GET_LENGTH_INFO: u32 = 475228u32;
3629 pub const IOCTL_DISK_GET_MEDIA_TYPES: u32 = 461824u32;
3630 pub const IOCTL_DISK_GET_PARTITION_INFO: u32 = 475140u32;
3631 pub const IOCTL_DISK_GET_PARTITION_INFO_EX: u32 = 458824u32;
3632 pub const IOCTL_DISK_GET_WRITE_CACHE_STATE: u32 = 475356u32;
3633 pub const IOCTL_DISK_GROW_PARTITION: u32 = 508112u32;
3634 pub const IOCTL_DISK_HISTOGRAM_DATA: u32 = 458804u32;
3635 pub const IOCTL_DISK_HISTOGRAM_RESET: u32 = 458808u32;
3636 pub const IOCTL_DISK_HISTOGRAM_STRUCTURE: u32 = 458800u32;
3637 pub const IOCTL_DISK_IS_WRITABLE: u32 = 458788u32;
3638 pub const IOCTL_DISK_LOAD_MEDIA: u32 = 477196u32;
3639 pub const IOCTL_DISK_LOGGING: u32 = 458792u32;
3640 pub const IOCTL_DISK_MEDIA_REMOVAL: u32 = 477188u32;
3641 pub const IOCTL_DISK_PERFORMANCE: u32 = 458784u32;
3642 pub const IOCTL_DISK_PERFORMANCE_OFF: u32 = 458848u32;
3643 pub const IOCTL_DISK_REASSIGN_BLOCKS: u32 = 507932u32;
3644 pub const IOCTL_DISK_REASSIGN_BLOCKS_EX: u32 = 508068u32;
3645 pub const IOCTL_DISK_RELEASE: u32 = 477204u32;
3646 pub const IOCTL_DISK_REQUEST_DATA: u32 = 458816u32;
3647 pub const IOCTL_DISK_REQUEST_STRUCTURE: u32 = 458812u32;
3648 pub const IOCTL_DISK_RESERVE: u32 = 477200u32;
3649 pub const IOCTL_DISK_RESET_SNAPSHOT_INFO: u32 = 508432u32;
3650 pub const IOCTL_DISK_SENSE_DEVICE: u32 = 459744u32;
3651 pub const IOCTL_DISK_SET_CACHE_INFORMATION: u32 = 508120u32;
3652 pub const IOCTL_DISK_SET_DISK_ATTRIBUTES: u32 = 508148u32;
3653 pub const IOCTL_DISK_SET_DRIVE_LAYOUT: u32 = 507920u32;
3654 pub const IOCTL_DISK_SET_DRIVE_LAYOUT_EX: u32 = 507988u32;
3655 pub const IOCTL_DISK_SET_PARTITION_INFO: u32 = 507912u32;
3656 pub const IOCTL_DISK_SET_PARTITION_INFO_EX: u32 = 507980u32;
3657 pub const IOCTL_DISK_UPDATE_DRIVE_SIZE: u32 = 508104u32;
3658 pub const IOCTL_DISK_UPDATE_PROPERTIES: u32 = 459072u32;
3659 pub const IOCTL_DISK_VERIFY: u32 = 458772u32;
3660 pub const IOCTL_SCMBUS_BASE: u32 = 89u32;
3661 pub const IOCTL_SCMBUS_DEVICE_FUNCTION_BASE: u32 = 0u32;
3662 pub const IOCTL_SCM_BUS_GET_LOGICAL_DEVICES: u32 = 5832704u32;
3663 pub const IOCTL_SCM_BUS_GET_PHYSICAL_DEVICES: u32 = 5832708u32;
3664 pub const IOCTL_SCM_BUS_GET_REGIONS: u32 = 5832712u32;
3665 pub const IOCTL_SCM_BUS_QUERY_PROPERTY: u32 = 5832716u32;
3666 pub const IOCTL_SCM_BUS_RUNTIME_FW_ACTIVATE: u32 = 5865488u32;
3667 pub const IOCTL_SCM_BUS_SET_PROPERTY: u32 = 5865492u32;
3668 pub const IOCTL_SCM_LD_GET_INTERLEAVE_SET: u32 = 5835776u32;
3669 pub const IOCTL_SCM_LOGICAL_DEVICE_FUNCTION_BASE: u32 = 768u32;
3670 pub const IOCTL_SCM_PD_FIRMWARE_ACTIVATE: u32 = 5871624u32;
3671 pub const IOCTL_SCM_PD_FIRMWARE_DOWNLOAD: u32 = 5871620u32;
3672 pub const IOCTL_SCM_PD_PASSTHROUGH: u32 = 5888012u32;
3673 pub const IOCTL_SCM_PD_QUERY_PROPERTY: u32 = 5838848u32;
3674 pub const IOCTL_SCM_PD_REINITIALIZE_MEDIA: u32 = 5871636u32;
3675 pub const IOCTL_SCM_PD_SET_PROPERTY: u32 = 5871640u32;
3676 pub const IOCTL_SCM_PD_UPDATE_MANAGEMENT_STATUS: u32 = 5838864u32;
3677 pub const IOCTL_SCM_PHYSICAL_DEVICE_FUNCTION_BASE: u32 = 1536u32;
3678 pub const IOCTL_SERENUM_EXPOSE_HARDWARE: u32 = 3604992u32;
3679 pub const IOCTL_SERENUM_GET_PORT_NAME: u32 = 3605004u32;
3680 pub const IOCTL_SERENUM_PORT_DESC: u32 = 3605000u32;
3681 pub const IOCTL_SERENUM_REMOVE_HARDWARE: u32 = 3604996u32;
3682 pub const IOCTL_SERIAL_LSRMST_INSERT: u32 = 1769596u32;
3683 pub const IOCTL_STORAGE_ALLOCATE_BC_STREAM: u32 = 3004420u32;
3684 pub const IOCTL_STORAGE_ATTRIBUTE_MANAGEMENT: u32 = 3005596u32;
3685 pub const IOCTL_STORAGE_BASE: u32 = 45u32;
3686 pub const IOCTL_STORAGE_BC_VERSION: u32 = 1u32;
3687 pub const IOCTL_STORAGE_BREAK_RESERVATION: u32 = 2969620u32;
3688 pub const IOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORT: u32 = 2955392u32;
3689 pub const IOCTL_STORAGE_CHECK_VERIFY: u32 = 2967552u32;
3690 pub const IOCTL_STORAGE_CHECK_VERIFY2: u32 = 2951168u32;
3691 pub const IOCTL_STORAGE_DEVICE_POWER_CAP: u32 = 2956436u32;
3692 pub const IOCTL_STORAGE_DEVICE_TELEMETRY_NOTIFY: u32 = 3002820u32;
3693 pub const IOCTL_STORAGE_DEVICE_TELEMETRY_QUERY_CAPS: u32 = 3002824u32;
3694 pub const IOCTL_STORAGE_DIAGNOSTIC: u32 = 2956448u32;
3695 pub const IOCTL_STORAGE_EJECTION_CONTROL: u32 = 2951488u32;
3696 pub const IOCTL_STORAGE_EJECT_MEDIA: u32 = 2967560u32;
3697 pub const IOCTL_STORAGE_ENABLE_IDLE_POWER: u32 = 2956416u32;
3698 pub const IOCTL_STORAGE_EVENT_NOTIFICATION: u32 = 2956432u32;
3699 pub const IOCTL_STORAGE_FAILURE_PREDICTION_CONFIG: u32 = 2953476u32;
3700 pub const IOCTL_STORAGE_FIND_NEW_DEVICES: u32 = 2967576u32;
3701 pub const IOCTL_STORAGE_FIRMWARE_ACTIVATE: u32 = 3005448u32;
3702 pub const IOCTL_STORAGE_FIRMWARE_DOWNLOAD: u32 = 3005444u32;
3703 pub const IOCTL_STORAGE_FIRMWARE_GET_INFO: u32 = 2956288u32;
3704 pub const IOCTL_STORAGE_FREE_BC_STREAM: u32 = 3004424u32;
3705 pub const IOCTL_STORAGE_GET_BC_PROPERTIES: u32 = 2971648u32;
3706 pub const IOCTL_STORAGE_GET_COUNTERS: u32 = 2953480u32;
3707 pub const IOCTL_STORAGE_GET_DEVICE_INTERNAL_LOG: u32 = 2956484u32;
3708 pub const IOCTL_STORAGE_GET_DEVICE_NUMBER: u32 = 2953344u32;
3709 pub const IOCTL_STORAGE_GET_DEVICE_NUMBER_EX: u32 = 2953348u32;
3710 pub const IOCTL_STORAGE_GET_DEVICE_TELEMETRY: u32 = 3002816u32;
3711 pub const IOCTL_STORAGE_GET_DEVICE_TELEMETRY_RAW: u32 = 3002828u32;
3712 pub const IOCTL_STORAGE_GET_HOTPLUG_INFO: u32 = 2952212u32;
3713 pub const IOCTL_STORAGE_GET_IDLE_POWERUP_REASON: u32 = 2956420u32;
3714 pub const IOCTL_STORAGE_GET_LB_PROVISIONING_MAP_RESOURCES: u32 = 2970632u32;
3715 pub const IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER: u32 = 2952208u32;
3716 pub const IOCTL_STORAGE_GET_MEDIA_TYPES: u32 = 2952192u32;
3717 pub const IOCTL_STORAGE_GET_MEDIA_TYPES_EX: u32 = 2952196u32;
3718 pub const IOCTL_STORAGE_GET_PHYSICAL_ELEMENT_STATUS: u32 = 2956452u32;
3719 pub const IOCTL_STORAGE_LOAD_MEDIA: u32 = 2967564u32;
3720 pub const IOCTL_STORAGE_LOAD_MEDIA2: u32 = 2951180u32;
3721 pub const IOCTL_STORAGE_MANAGE_BYPASS_IO: u32 = 2951360u32;
3722 pub const IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES: u32 = 2987012u32;
3723 pub const IOCTL_STORAGE_MCN_CONTROL: u32 = 2951492u32;
3724 pub const IOCTL_STORAGE_MEDIA_REMOVAL: u32 = 2967556u32;
3725 pub const IOCTL_STORAGE_PERSISTENT_RESERVE_IN: u32 = 2969624u32;
3726 pub const IOCTL_STORAGE_PERSISTENT_RESERVE_OUT: u32 = 3002396u32;
3727 pub const IOCTL_STORAGE_POWER_ACTIVE: u32 = 2956424u32;
3728 pub const IOCTL_STORAGE_POWER_IDLE: u32 = 2956428u32;
3729 pub const IOCTL_STORAGE_PREDICT_FAILURE: u32 = 2953472u32;
3730 pub const IOCTL_STORAGE_PROTOCOL_COMMAND: u32 = 3003328u32;
3731 pub const IOCTL_STORAGE_QUERY_PROPERTY: u32 = 2954240u32;
3732 pub const IOCTL_STORAGE_READ_CAPACITY: u32 = 2969920u32;
3733 pub const IOCTL_STORAGE_REINITIALIZE_MEDIA: u32 = 2987584u32;
3734 pub const IOCTL_STORAGE_RELEASE: u32 = 2967572u32;
3735 pub const IOCTL_STORAGE_REMOVE_ELEMENT_AND_TRUNCATE: u32 = 2956480u32;
3736 pub const IOCTL_STORAGE_RESERVE: u32 = 2967568u32;
3737 pub const IOCTL_STORAGE_RESET_BUS: u32 = 2969600u32;
3738 pub const IOCTL_STORAGE_RESET_DEVICE: u32 = 2969604u32;
3739 pub const IOCTL_STORAGE_RPMB_COMMAND: u32 = 2956440u32;
3740 pub const IOCTL_STORAGE_SET_HOTPLUG_INFO: u32 = 3001368u32;
3741 pub const IOCTL_STORAGE_SET_PROPERTY: u32 = 2987004u32;
3742 pub const IOCTL_STORAGE_SET_TEMPERATURE_THRESHOLD: u32 = 3002880u32;
3743 pub const IOCTL_STORAGE_START_DATA_INTEGRITY_CHECK: u32 = 3004548u32;
3744 pub const IOCTL_STORAGE_STOP_DATA_INTEGRITY_CHECK: u32 = 3004552u32;
3745 #[repr(C)]
3746 pub struct IO_IRP_EXT_TRACK_OFFSET_HEADER {
3747     pub Validation: u16,
3748     pub Flags: u16,
3749     pub TrackedOffsetCallback: PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK,
3750 }
3751 impl ::core::marker::Copy for IO_IRP_EXT_TRACK_OFFSET_HEADER {}
3752 impl ::core::clone::Clone for IO_IRP_EXT_TRACK_OFFSET_HEADER {
3753     fn clone(&self) -> Self {
3754         *self
3755     }
3756 }
3757 pub const LOCK_ELEMENT: u32 = 0u32;
3758 pub const LOCK_UNLOCK_DOOR: u32 = 2u32;
3759 pub const LOCK_UNLOCK_IEPORT: u32 = 1u32;
3760 pub const LOCK_UNLOCK_KEYPAD: u32 = 4u32;
3761 #[repr(C)]
3762 pub struct LOOKUP_STREAM_FROM_CLUSTER_ENTRY {
3763     pub OffsetToNext: u32,
3764     pub Flags: u32,
3765     pub Reserved: i64,
3766     pub Cluster: i64,
3767     pub FileName: [u16; 1],
3768 }
3769 impl ::core::marker::Copy for LOOKUP_STREAM_FROM_CLUSTER_ENTRY {}
3770 impl ::core::clone::Clone for LOOKUP_STREAM_FROM_CLUSTER_ENTRY {
3771     fn clone(&self) -> Self {
3772         *self
3773     }
3774 }
3775 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_DATA: u32 = 16777216u32;
3776 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_INDEX: u32 = 33554432u32;
3777 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_MASK: u32 = 4278190080u32;
3778 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_ATTRIBUTE_SYSTEM: u32 = 50331648u32;
3779 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_DENY_DEFRAG_SET: u32 = 2u32;
3780 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_FS_SYSTEM_FILE: u32 = 4u32;
3781 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_PAGE_FILE: u32 = 1u32;
3782 pub const LOOKUP_STREAM_FROM_CLUSTER_ENTRY_FLAG_TXF_SYSTEM_FILE: u32 = 8u32;
3783 #[repr(C)]
3784 pub struct LOOKUP_STREAM_FROM_CLUSTER_INPUT {
3785     pub Flags: u32,
3786     pub NumberOfClusters: u32,
3787     pub Cluster: [i64; 1],
3788 }
3789 impl ::core::marker::Copy for LOOKUP_STREAM_FROM_CLUSTER_INPUT {}
3790 impl ::core::clone::Clone for LOOKUP_STREAM_FROM_CLUSTER_INPUT {
3791     fn clone(&self) -> Self {
3792         *self
3793     }
3794 }
3795 #[repr(C)]
3796 pub struct LOOKUP_STREAM_FROM_CLUSTER_OUTPUT {
3797     pub Offset: u32,
3798     pub NumberOfMatches: u32,
3799     pub BufferSizeRequired: u32,
3800 }
3801 impl ::core::marker::Copy for LOOKUP_STREAM_FROM_CLUSTER_OUTPUT {}
3802 impl ::core::clone::Clone for LOOKUP_STREAM_FROM_CLUSTER_OUTPUT {
3803     fn clone(&self) -> Self {
3804         *self
3805     }
3806 }
3807 pub const MARK_HANDLE_CLOUD_SYNC: u32 = 2048u32;
3808 pub const MARK_HANDLE_DISABLE_FILE_METADATA_OPTIMIZATION: u32 = 4096u32;
3809 pub const MARK_HANDLE_ENABLE_CPU_CACHE: u32 = 268435456u32;
3810 pub const MARK_HANDLE_ENABLE_USN_SOURCE_ON_PAGING_IO: u32 = 8192u32;
3811 pub const MARK_HANDLE_FILTER_METADATA: u32 = 512u32;
3812 #[repr(C)]
3813 #[cfg(feature = "Win32_Foundation")]
3814 pub struct MARK_HANDLE_INFO {
3815     pub Anonymous: MARK_HANDLE_INFO_0,
3816     pub VolumeHandle: super::super::Foundation::HANDLE,
3817     pub HandleInfo: u32,
3818 }
3819 #[cfg(feature = "Win32_Foundation")]
3820 impl ::core::marker::Copy for MARK_HANDLE_INFO {}
3821 #[cfg(feature = "Win32_Foundation")]
3822 impl ::core::clone::Clone for MARK_HANDLE_INFO {
3823     fn clone(&self) -> Self {
3824         *self
3825     }
3826 }
3827 #[repr(C)]
3828 #[cfg(feature = "Win32_Foundation")]
3829 pub union MARK_HANDLE_INFO_0 {
3830     pub UsnSourceInfo: u32,
3831     pub CopyNumber: u32,
3832 }
3833 #[cfg(feature = "Win32_Foundation")]
3834 impl ::core::marker::Copy for MARK_HANDLE_INFO_0 {}
3835 #[cfg(feature = "Win32_Foundation")]
3836 impl ::core::clone::Clone for MARK_HANDLE_INFO_0 {
3837     fn clone(&self) -> Self {
3838         *self
3839     }
3840 }
3841 #[repr(C)]
3842 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3843 pub struct MARK_HANDLE_INFO32 {
3844     pub Anonymous: MARK_HANDLE_INFO32_0,
3845     pub VolumeHandle: u32,
3846     pub HandleInfo: u32,
3847 }
3848 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3849 impl ::core::marker::Copy for MARK_HANDLE_INFO32 {}
3850 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3851 impl ::core::clone::Clone for MARK_HANDLE_INFO32 {
3852     fn clone(&self) -> Self {
3853         *self
3854     }
3855 }
3856 #[repr(C)]
3857 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3858 pub union MARK_HANDLE_INFO32_0 {
3859     pub UsnSourceInfo: u32,
3860     pub CopyNumber: u32,
3861 }
3862 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3863 impl ::core::marker::Copy for MARK_HANDLE_INFO32_0 {}
3864 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3865 impl ::core::clone::Clone for MARK_HANDLE_INFO32_0 {
3866     fn clone(&self) -> Self {
3867         *self
3868     }
3869 }
3870 pub const MARK_HANDLE_NOT_READ_COPY: u32 = 256u32;
3871 pub const MARK_HANDLE_NOT_REALTIME: u32 = 64u32;
3872 pub const MARK_HANDLE_NOT_TXF_SYSTEM_LOG: u32 = 8u32;
3873 pub const MARK_HANDLE_PROTECT_CLUSTERS: u32 = 1u32;
3874 pub const MARK_HANDLE_READ_COPY: u32 = 128u32;
3875 pub const MARK_HANDLE_REALTIME: u32 = 32u32;
3876 pub const MARK_HANDLE_RETURN_PURGE_FAILURE: u32 = 1024u32;
3877 pub const MARK_HANDLE_SKIP_COHERENCY_SYNC_DISALLOW_WRITES: u32 = 16384u32;
3878 pub const MARK_HANDLE_SUPPRESS_VOLUME_OPEN_FLUSH: u32 = 32768u32;
3879 pub const MARK_HANDLE_TXF_SYSTEM_LOG: u32 = 4u32;
3880 pub const MAXIMUM_ENCRYPTION_VALUE: u32 = 4u32;
3881 pub const MAX_FW_BUCKET_ID_LENGTH: u32 = 132u32;
3882 pub const MAX_INTERFACE_CODES: u32 = 8u32;
3883 pub const MAX_VOLUME_ID_SIZE: u32 = 36u32;
3884 pub const MAX_VOLUME_TEMPLATE_SIZE: u32 = 40u32;
3885 pub const MEDIA_CURRENTLY_MOUNTED: u32 = 2147483648u32;
3886 pub const MEDIA_ERASEABLE: u32 = 1u32;
3887 pub const MEDIA_READ_ONLY: u32 = 4u32;
3888 pub const MEDIA_READ_WRITE: u32 = 8u32;
3889 pub type MEDIA_TYPE = i32;
3890 pub const Unknown: MEDIA_TYPE = 0i32;
3891 pub const F5_1Pt2_512: MEDIA_TYPE = 1i32;
3892 pub const F3_1Pt44_512: MEDIA_TYPE = 2i32;
3893 pub const F3_2Pt88_512: MEDIA_TYPE = 3i32;
3894 pub const F3_20Pt8_512: MEDIA_TYPE = 4i32;
3895 pub const F3_720_512: MEDIA_TYPE = 5i32;
3896 pub const F5_360_512: MEDIA_TYPE = 6i32;
3897 pub const F5_320_512: MEDIA_TYPE = 7i32;
3898 pub const F5_320_1024: MEDIA_TYPE = 8i32;
3899 pub const F5_180_512: MEDIA_TYPE = 9i32;
3900 pub const F5_160_512: MEDIA_TYPE = 10i32;
3901 pub const RemovableMedia: MEDIA_TYPE = 11i32;
3902 pub const FixedMedia: MEDIA_TYPE = 12i32;
3903 pub const F3_120M_512: MEDIA_TYPE = 13i32;
3904 pub const F3_640_512: MEDIA_TYPE = 14i32;
3905 pub const F5_640_512: MEDIA_TYPE = 15i32;
3906 pub const F5_720_512: MEDIA_TYPE = 16i32;
3907 pub const F3_1Pt2_512: MEDIA_TYPE = 17i32;
3908 pub const F3_1Pt23_1024: MEDIA_TYPE = 18i32;
3909 pub const F5_1Pt23_1024: MEDIA_TYPE = 19i32;
3910 pub const F3_128Mb_512: MEDIA_TYPE = 20i32;
3911 pub const F3_230Mb_512: MEDIA_TYPE = 21i32;
3912 pub const F8_256_128: MEDIA_TYPE = 22i32;
3913 pub const F3_200Mb_512: MEDIA_TYPE = 23i32;
3914 pub const F3_240M_512: MEDIA_TYPE = 24i32;
3915 pub const F3_32M_512: MEDIA_TYPE = 25i32;
3916 pub const MEDIA_WRITE_ONCE: u32 = 2u32;
3917 pub const MEDIA_WRITE_PROTECTED: u32 = 256u32;
3918 pub const METHOD_BUFFERED: u32 = 0u32;
3919 pub const METHOD_DIRECT_FROM_HARDWARE: u32 = 2u32;
3920 pub const METHOD_DIRECT_TO_HARDWARE: u32 = 1u32;
3921 pub const METHOD_IN_DIRECT: u32 = 1u32;
3922 pub const METHOD_NEITHER: u32 = 3u32;
3923 pub const METHOD_OUT_DIRECT: u32 = 2u32;
3924 #[repr(C)]
3925 pub struct MFT_ENUM_DATA_V0 {
3926     pub StartFileReferenceNumber: u64,
3927     pub LowUsn: i64,
3928     pub HighUsn: i64,
3929 }
3930 impl ::core::marker::Copy for MFT_ENUM_DATA_V0 {}
3931 impl ::core::clone::Clone for MFT_ENUM_DATA_V0 {
3932     fn clone(&self) -> Self {
3933         *self
3934     }
3935 }
3936 #[repr(C)]
3937 pub struct MFT_ENUM_DATA_V1 {
3938     pub StartFileReferenceNumber: u64,
3939     pub LowUsn: i64,
3940     pub HighUsn: i64,
3941     pub MinMajorVersion: u16,
3942     pub MaxMajorVersion: u16,
3943 }
3944 impl ::core::marker::Copy for MFT_ENUM_DATA_V1 {}
3945 impl ::core::clone::Clone for MFT_ENUM_DATA_V1 {
3946     fn clone(&self) -> Self {
3947         *self
3948     }
3949 }
3950 #[repr(C)]
3951 #[cfg(feature = "Win32_Foundation")]
3952 pub struct MOVE_FILE_DATA {
3953     pub FileHandle: super::super::Foundation::HANDLE,
3954     pub StartingVcn: i64,
3955     pub StartingLcn: i64,
3956     pub ClusterCount: u32,
3957 }
3958 #[cfg(feature = "Win32_Foundation")]
3959 impl ::core::marker::Copy for MOVE_FILE_DATA {}
3960 #[cfg(feature = "Win32_Foundation")]
3961 impl ::core::clone::Clone for MOVE_FILE_DATA {
3962     fn clone(&self) -> Self {
3963         *self
3964     }
3965 }
3966 #[repr(C)]
3967 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3968 pub struct MOVE_FILE_DATA32 {
3969     pub FileHandle: u32,
3970     pub StartingVcn: i64,
3971     pub StartingLcn: i64,
3972     pub ClusterCount: u32,
3973 }
3974 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3975 impl ::core::marker::Copy for MOVE_FILE_DATA32 {}
3976 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
3977 impl ::core::clone::Clone for MOVE_FILE_DATA32 {
3978     fn clone(&self) -> Self {
3979         *self
3980     }
3981 }
3982 #[repr(C)]
3983 #[cfg(feature = "Win32_Foundation")]
3984 pub struct MOVE_FILE_RECORD_DATA {
3985     pub FileHandle: super::super::Foundation::HANDLE,
3986     pub SourceFileRecord: i64,
3987     pub TargetFileRecord: i64,
3988 }
3989 #[cfg(feature = "Win32_Foundation")]
3990 impl ::core::marker::Copy for MOVE_FILE_RECORD_DATA {}
3991 #[cfg(feature = "Win32_Foundation")]
3992 impl ::core::clone::Clone for MOVE_FILE_RECORD_DATA {
3993     fn clone(&self) -> Self {
3994         *self
3995     }
3996 }
3997 #[repr(C)]
3998 pub struct NTFS_EXTENDED_VOLUME_DATA {
3999     pub ByteCount: u32,
4000     pub MajorVersion: u16,
4001     pub MinorVersion: u16,
4002     pub BytesPerPhysicalSector: u32,
4003     pub LfsMajorVersion: u16,
4004     pub LfsMinorVersion: u16,
4005     pub MaxDeviceTrimExtentCount: u32,
4006     pub MaxDeviceTrimByteCount: u32,
4007     pub MaxVolumeTrimExtentCount: u32,
4008     pub MaxVolumeTrimByteCount: u32,
4009 }
4010 impl ::core::marker::Copy for NTFS_EXTENDED_VOLUME_DATA {}
4011 impl ::core::clone::Clone for NTFS_EXTENDED_VOLUME_DATA {
4012     fn clone(&self) -> Self {
4013         *self
4014     }
4015 }
4016 #[repr(C)]
4017 pub struct NTFS_FILE_RECORD_INPUT_BUFFER {
4018     pub FileReferenceNumber: i64,
4019 }
4020 impl ::core::marker::Copy for NTFS_FILE_RECORD_INPUT_BUFFER {}
4021 impl ::core::clone::Clone for NTFS_FILE_RECORD_INPUT_BUFFER {
4022     fn clone(&self) -> Self {
4023         *self
4024     }
4025 }
4026 #[repr(C)]
4027 pub struct NTFS_FILE_RECORD_OUTPUT_BUFFER {
4028     pub FileReferenceNumber: i64,
4029     pub FileRecordLength: u32,
4030     pub FileRecordBuffer: [u8; 1],
4031 }
4032 impl ::core::marker::Copy for NTFS_FILE_RECORD_OUTPUT_BUFFER {}
4033 impl ::core::clone::Clone for NTFS_FILE_RECORD_OUTPUT_BUFFER {
4034     fn clone(&self) -> Self {
4035         *self
4036     }
4037 }
4038 #[repr(C)]
4039 pub struct NTFS_STATISTICS {
4040     pub LogFileFullExceptions: u32,
4041     pub OtherExceptions: u32,
4042     pub MftReads: u32,
4043     pub MftReadBytes: u32,
4044     pub MftWrites: u32,
4045     pub MftWriteBytes: u32,
4046     pub MftWritesUserLevel: NTFS_STATISTICS_4,
4047     pub MftWritesFlushForLogFileFull: u16,
4048     pub MftWritesLazyWriter: u16,
4049     pub MftWritesUserRequest: u16,
4050     pub Mft2Writes: u32,
4051     pub Mft2WriteBytes: u32,
4052     pub Mft2WritesUserLevel: NTFS_STATISTICS_2,
4053     pub Mft2WritesFlushForLogFileFull: u16,
4054     pub Mft2WritesLazyWriter: u16,
4055     pub Mft2WritesUserRequest: u16,
4056     pub RootIndexReads: u32,
4057     pub RootIndexReadBytes: u32,
4058     pub RootIndexWrites: u32,
4059     pub RootIndexWriteBytes: u32,
4060     pub BitmapReads: u32,
4061     pub BitmapReadBytes: u32,
4062     pub BitmapWrites: u32,
4063     pub BitmapWriteBytes: u32,
4064     pub BitmapWritesFlushForLogFileFull: u16,
4065     pub BitmapWritesLazyWriter: u16,
4066     pub BitmapWritesUserRequest: u16,
4067     pub BitmapWritesUserLevel: NTFS_STATISTICS_1,
4068     pub MftBitmapReads: u32,
4069     pub MftBitmapReadBytes: u32,
4070     pub MftBitmapWrites: u32,
4071     pub MftBitmapWriteBytes: u32,
4072     pub MftBitmapWritesFlushForLogFileFull: u16,
4073     pub MftBitmapWritesLazyWriter: u16,
4074     pub MftBitmapWritesUserRequest: u16,
4075     pub MftBitmapWritesUserLevel: NTFS_STATISTICS_3,
4076     pub UserIndexReads: u32,
4077     pub UserIndexReadBytes: u32,
4078     pub UserIndexWrites: u32,
4079     pub UserIndexWriteBytes: u32,
4080     pub LogFileReads: u32,
4081     pub LogFileReadBytes: u32,
4082     pub LogFileWrites: u32,
4083     pub LogFileWriteBytes: u32,
4084     pub Allocate: NTFS_STATISTICS_0,
4085     pub DiskResourcesExhausted: u32,
4086 }
4087 impl ::core::marker::Copy for NTFS_STATISTICS {}
4088 impl ::core::clone::Clone for NTFS_STATISTICS {
4089     fn clone(&self) -> Self {
4090         *self
4091     }
4092 }
4093 #[repr(C)]
4094 pub struct NTFS_STATISTICS_0 {
4095     pub Calls: u32,
4096     pub Clusters: u32,
4097     pub Hints: u32,
4098     pub RunsReturned: u32,
4099     pub HintsHonored: u32,
4100     pub HintsClusters: u32,
4101     pub Cache: u32,
4102     pub CacheClusters: u32,
4103     pub CacheMiss: u32,
4104     pub CacheMissClusters: u32,
4105 }
4106 impl ::core::marker::Copy for NTFS_STATISTICS_0 {}
4107 impl ::core::clone::Clone for NTFS_STATISTICS_0 {
4108     fn clone(&self) -> Self {
4109         *self
4110     }
4111 }
4112 #[repr(C)]
4113 pub struct NTFS_STATISTICS_1 {
4114     pub Write: u16,
4115     pub Create: u16,
4116     pub SetInfo: u16,
4117 }
4118 impl ::core::marker::Copy for NTFS_STATISTICS_1 {}
4119 impl ::core::clone::Clone for NTFS_STATISTICS_1 {
4120     fn clone(&self) -> Self {
4121         *self
4122     }
4123 }
4124 #[repr(C)]
4125 pub struct NTFS_STATISTICS_2 {
4126     pub Write: u16,
4127     pub Create: u16,
4128     pub SetInfo: u16,
4129     pub Flush: u16,
4130 }
4131 impl ::core::marker::Copy for NTFS_STATISTICS_2 {}
4132 impl ::core::clone::Clone for NTFS_STATISTICS_2 {
4133     fn clone(&self) -> Self {
4134         *self
4135     }
4136 }
4137 #[repr(C)]
4138 pub struct NTFS_STATISTICS_3 {
4139     pub Write: u16,
4140     pub Create: u16,
4141     pub SetInfo: u16,
4142     pub Flush: u16,
4143 }
4144 impl ::core::marker::Copy for NTFS_STATISTICS_3 {}
4145 impl ::core::clone::Clone for NTFS_STATISTICS_3 {
4146     fn clone(&self) -> Self {
4147         *self
4148     }
4149 }
4150 #[repr(C)]
4151 pub struct NTFS_STATISTICS_4 {
4152     pub Write: u16,
4153     pub Create: u16,
4154     pub SetInfo: u16,
4155     pub Flush: u16,
4156 }
4157 impl ::core::marker::Copy for NTFS_STATISTICS_4 {}
4158 impl ::core::clone::Clone for NTFS_STATISTICS_4 {
4159     fn clone(&self) -> Self {
4160         *self
4161     }
4162 }
4163 #[repr(C)]
4164 pub struct NTFS_STATISTICS_EX {
4165     pub LogFileFullExceptions: u32,
4166     pub OtherExceptions: u32,
4167     pub MftReads: u64,
4168     pub MftReadBytes: u64,
4169     pub MftWrites: u64,
4170     pub MftWriteBytes: u64,
4171     pub MftWritesUserLevel: NTFS_STATISTICS_EX_4,
4172     pub MftWritesFlushForLogFileFull: u32,
4173     pub MftWritesLazyWriter: u32,
4174     pub MftWritesUserRequest: u32,
4175     pub Mft2Writes: u64,
4176     pub Mft2WriteBytes: u64,
4177     pub Mft2WritesUserLevel: NTFS_STATISTICS_EX_2,
4178     pub Mft2WritesFlushForLogFileFull: u32,
4179     pub Mft2WritesLazyWriter: u32,
4180     pub Mft2WritesUserRequest: u32,
4181     pub RootIndexReads: u64,
4182     pub RootIndexReadBytes: u64,
4183     pub RootIndexWrites: u64,
4184     pub RootIndexWriteBytes: u64,
4185     pub BitmapReads: u64,
4186     pub BitmapReadBytes: u64,
4187     pub BitmapWrites: u64,
4188     pub BitmapWriteBytes: u64,
4189     pub BitmapWritesFlushForLogFileFull: u32,
4190     pub BitmapWritesLazyWriter: u32,
4191     pub BitmapWritesUserRequest: u32,
4192     pub BitmapWritesUserLevel: NTFS_STATISTICS_EX_1,
4193     pub MftBitmapReads: u64,
4194     pub MftBitmapReadBytes: u64,
4195     pub MftBitmapWrites: u64,
4196     pub MftBitmapWriteBytes: u64,
4197     pub MftBitmapWritesFlushForLogFileFull: u32,
4198     pub MftBitmapWritesLazyWriter: u32,
4199     pub MftBitmapWritesUserRequest: u32,
4200     pub MftBitmapWritesUserLevel: NTFS_STATISTICS_EX_3,
4201     pub UserIndexReads: u64,
4202     pub UserIndexReadBytes: u64,
4203     pub UserIndexWrites: u64,
4204     pub UserIndexWriteBytes: u64,
4205     pub LogFileReads: u64,
4206     pub LogFileReadBytes: u64,
4207     pub LogFileWrites: u64,
4208     pub LogFileWriteBytes: u64,
4209     pub Allocate: NTFS_STATISTICS_EX_0,
4210     pub DiskResourcesExhausted: u32,
4211     pub VolumeTrimCount: u64,
4212     pub VolumeTrimTime: u64,
4213     pub VolumeTrimByteCount: u64,
4214     pub FileLevelTrimCount: u64,
4215     pub FileLevelTrimTime: u64,
4216     pub FileLevelTrimByteCount: u64,
4217     pub VolumeTrimSkippedCount: u64,
4218     pub VolumeTrimSkippedByteCount: u64,
4219     pub NtfsFillStatInfoFromMftRecordCalledCount: u64,
4220     pub NtfsFillStatInfoFromMftRecordBailedBecauseOfAttributeListCount: u64,
4221     pub NtfsFillStatInfoFromMftRecordBailedBecauseOfNonResReparsePointCount: u64,
4222 }
4223 impl ::core::marker::Copy for NTFS_STATISTICS_EX {}
4224 impl ::core::clone::Clone for NTFS_STATISTICS_EX {
4225     fn clone(&self) -> Self {
4226         *self
4227     }
4228 }
4229 #[repr(C)]
4230 pub struct NTFS_STATISTICS_EX_0 {
4231     pub Calls: u32,
4232     pub RunsReturned: u32,
4233     pub Hints: u32,
4234     pub HintsHonored: u32,
4235     pub Cache: u32,
4236     pub CacheMiss: u32,
4237     pub Clusters: u64,
4238     pub HintsClusters: u64,
4239     pub CacheClusters: u64,
4240     pub CacheMissClusters: u64,
4241 }
4242 impl ::core::marker::Copy for NTFS_STATISTICS_EX_0 {}
4243 impl ::core::clone::Clone for NTFS_STATISTICS_EX_0 {
4244     fn clone(&self) -> Self {
4245         *self
4246     }
4247 }
4248 #[repr(C)]
4249 pub struct NTFS_STATISTICS_EX_1 {
4250     pub Write: u32,
4251     pub Create: u32,
4252     pub SetInfo: u32,
4253     pub Flush: u32,
4254 }
4255 impl ::core::marker::Copy for NTFS_STATISTICS_EX_1 {}
4256 impl ::core::clone::Clone for NTFS_STATISTICS_EX_1 {
4257     fn clone(&self) -> Self {
4258         *self
4259     }
4260 }
4261 #[repr(C)]
4262 pub struct NTFS_STATISTICS_EX_2 {
4263     pub Write: u32,
4264     pub Create: u32,
4265     pub SetInfo: u32,
4266     pub Flush: u32,
4267 }
4268 impl ::core::marker::Copy for NTFS_STATISTICS_EX_2 {}
4269 impl ::core::clone::Clone for NTFS_STATISTICS_EX_2 {
4270     fn clone(&self) -> Self {
4271         *self
4272     }
4273 }
4274 #[repr(C)]
4275 pub struct NTFS_STATISTICS_EX_3 {
4276     pub Write: u32,
4277     pub Create: u32,
4278     pub SetInfo: u32,
4279     pub Flush: u32,
4280 }
4281 impl ::core::marker::Copy for NTFS_STATISTICS_EX_3 {}
4282 impl ::core::clone::Clone for NTFS_STATISTICS_EX_3 {
4283     fn clone(&self) -> Self {
4284         *self
4285     }
4286 }
4287 #[repr(C)]
4288 pub struct NTFS_STATISTICS_EX_4 {
4289     pub Write: u32,
4290     pub Create: u32,
4291     pub SetInfo: u32,
4292     pub Flush: u32,
4293 }
4294 impl ::core::marker::Copy for NTFS_STATISTICS_EX_4 {}
4295 impl ::core::clone::Clone for NTFS_STATISTICS_EX_4 {
4296     fn clone(&self) -> Self {
4297         *self
4298     }
4299 }
4300 #[repr(C)]
4301 pub struct NTFS_VOLUME_DATA_BUFFER {
4302     pub VolumeSerialNumber: i64,
4303     pub NumberSectors: i64,
4304     pub TotalClusters: i64,
4305     pub FreeClusters: i64,
4306     pub TotalReserved: i64,
4307     pub BytesPerSector: u32,
4308     pub BytesPerCluster: u32,
4309     pub BytesPerFileRecordSegment: u32,
4310     pub ClustersPerFileRecordSegment: u32,
4311     pub MftValidDataLength: i64,
4312     pub MftStartLcn: i64,
4313     pub Mft2StartLcn: i64,
4314     pub MftZoneStart: i64,
4315     pub MftZoneEnd: i64,
4316 }
4317 impl ::core::marker::Copy for NTFS_VOLUME_DATA_BUFFER {}
4318 impl ::core::clone::Clone for NTFS_VOLUME_DATA_BUFFER {
4319     fn clone(&self) -> Self {
4320         *self
4321     }
4322 }
4323 pub const OBSOLETE_DISK_GET_WRITE_CACHE_STATE: u32 = 475356u32;
4324 pub const OBSOLETE_IOCTL_STORAGE_RESET_BUS: u32 = 3002368u32;
4325 pub const OBSOLETE_IOCTL_STORAGE_RESET_DEVICE: u32 = 3002372u32;
4326 pub const OFFLOAD_READ_FLAG_ALL_ZERO_BEYOND_CURRENT_RANGE: u32 = 1u32;
4327 pub const OPLOCK_LEVEL_CACHE_HANDLE: u32 = 2u32;
4328 pub const OPLOCK_LEVEL_CACHE_READ: u32 = 1u32;
4329 pub const OPLOCK_LEVEL_CACHE_WRITE: u32 = 4u32;
4330 pub const PARTIITON_OS_DATA: u32 = 41u32;
4331 pub const PARTITION_BSP: u32 = 43u32;
4332 pub const PARTITION_DM: u32 = 84u32;
4333 pub const PARTITION_DPP: u32 = 44u32;
4334 pub const PARTITION_ENTRY_UNUSED: u32 = 0u32;
4335 pub const PARTITION_EXTENDED: u32 = 5u32;
4336 pub const PARTITION_EZDRIVE: u32 = 85u32;
4337 pub const PARTITION_FAT32: u32 = 11u32;
4338 pub const PARTITION_FAT32_XINT13: u32 = 12u32;
4339 pub const PARTITION_FAT_12: u32 = 1u32;
4340 pub const PARTITION_FAT_16: u32 = 4u32;
4341 pub const PARTITION_GPT: u32 = 238u32;
4342 pub const PARTITION_HUGE: u32 = 6u32;
4343 pub const PARTITION_IFS: u32 = 7u32;
4344 #[repr(C)]
4345 #[cfg(feature = "Win32_Foundation")]
4346 pub struct PARTITION_INFORMATION {
4347     pub StartingOffset: i64,
4348     pub PartitionLength: i64,
4349     pub HiddenSectors: u32,
4350     pub PartitionNumber: u32,
4351     pub PartitionType: u8,
4352     pub BootIndicator: super::super::Foundation::BOOLEAN,
4353     pub RecognizedPartition: super::super::Foundation::BOOLEAN,
4354     pub RewritePartition: super::super::Foundation::BOOLEAN,
4355 }
4356 #[cfg(feature = "Win32_Foundation")]
4357 impl ::core::marker::Copy for PARTITION_INFORMATION {}
4358 #[cfg(feature = "Win32_Foundation")]
4359 impl ::core::clone::Clone for PARTITION_INFORMATION {
4360     fn clone(&self) -> Self {
4361         *self
4362     }
4363 }
4364 #[repr(C)]
4365 #[cfg(feature = "Win32_Foundation")]
4366 pub struct PARTITION_INFORMATION_EX {
4367     pub PartitionStyle: PARTITION_STYLE,
4368     pub StartingOffset: i64,
4369     pub PartitionLength: i64,
4370     pub PartitionNumber: u32,
4371     pub RewritePartition: super::super::Foundation::BOOLEAN,
4372     pub IsServicePartition: super::super::Foundation::BOOLEAN,
4373     pub Anonymous: PARTITION_INFORMATION_EX_0,
4374 }
4375 #[cfg(feature = "Win32_Foundation")]
4376 impl ::core::marker::Copy for PARTITION_INFORMATION_EX {}
4377 #[cfg(feature = "Win32_Foundation")]
4378 impl ::core::clone::Clone for PARTITION_INFORMATION_EX {
4379     fn clone(&self) -> Self {
4380         *self
4381     }
4382 }
4383 #[repr(C)]
4384 #[cfg(feature = "Win32_Foundation")]
4385 pub union PARTITION_INFORMATION_EX_0 {
4386     pub Mbr: PARTITION_INFORMATION_MBR,
4387     pub Gpt: PARTITION_INFORMATION_GPT,
4388 }
4389 #[cfg(feature = "Win32_Foundation")]
4390 impl ::core::marker::Copy for PARTITION_INFORMATION_EX_0 {}
4391 #[cfg(feature = "Win32_Foundation")]
4392 impl ::core::clone::Clone for PARTITION_INFORMATION_EX_0 {
4393     fn clone(&self) -> Self {
4394         *self
4395     }
4396 }
4397 #[repr(C)]
4398 pub struct PARTITION_INFORMATION_GPT {
4399     pub PartitionType: ::windows_sys::core::GUID,
4400     pub PartitionId: ::windows_sys::core::GUID,
4401     pub Attributes: GPT_ATTRIBUTES,
4402     pub Name: [u16; 36],
4403 }
4404 impl ::core::marker::Copy for PARTITION_INFORMATION_GPT {}
4405 impl ::core::clone::Clone for PARTITION_INFORMATION_GPT {
4406     fn clone(&self) -> Self {
4407         *self
4408     }
4409 }
4410 #[repr(C)]
4411 #[cfg(feature = "Win32_Foundation")]
4412 pub struct PARTITION_INFORMATION_MBR {
4413     pub PartitionType: u8,
4414     pub BootIndicator: super::super::Foundation::BOOLEAN,
4415     pub RecognizedPartition: super::super::Foundation::BOOLEAN,
4416     pub HiddenSectors: u32,
4417     pub PartitionId: ::windows_sys::core::GUID,
4418 }
4419 #[cfg(feature = "Win32_Foundation")]
4420 impl ::core::marker::Copy for PARTITION_INFORMATION_MBR {}
4421 #[cfg(feature = "Win32_Foundation")]
4422 impl ::core::clone::Clone for PARTITION_INFORMATION_MBR {
4423     fn clone(&self) -> Self {
4424         *self
4425     }
4426 }
4427 pub const PARTITION_LDM: u32 = 66u32;
4428 pub const PARTITION_MAIN_OS: u32 = 40u32;
4429 pub const PARTITION_MSFT_RECOVERY: u32 = 39u32;
4430 pub const PARTITION_NTFT: u32 = 128u32;
4431 pub const PARTITION_OS2BOOTMGR: u32 = 10u32;
4432 pub const PARTITION_PREP: u32 = 65u32;
4433 pub const PARTITION_PRE_INSTALLED: u32 = 42u32;
4434 pub const PARTITION_SPACES: u32 = 231u32;
4435 pub const PARTITION_SPACES_DATA: u32 = 215u32;
4436 pub type PARTITION_STYLE = i32;
4437 pub const PARTITION_STYLE_MBR: PARTITION_STYLE = 0i32;
4438 pub const PARTITION_STYLE_GPT: PARTITION_STYLE = 1i32;
4439 pub const PARTITION_STYLE_RAW: PARTITION_STYLE = 2i32;
4440 pub const PARTITION_SYSTEM: u32 = 239u32;
4441 pub const PARTITION_UNIX: u32 = 99u32;
4442 pub const PARTITION_WINDOWS_SYSTEM: u32 = 45u32;
4443 pub const PARTITION_XENIX_1: u32 = 2u32;
4444 pub const PARTITION_XENIX_2: u32 = 3u32;
4445 pub const PARTITION_XINT13: u32 = 14u32;
4446 pub const PARTITION_XINT13_EXTENDED: u32 = 15u32;
4447 #[repr(C)]
4448 pub struct PATHNAME_BUFFER {
4449     pub PathNameLength: u32,
4450     pub Name: [u16; 1],
4451 }
4452 impl ::core::marker::Copy for PATHNAME_BUFFER {}
4453 impl ::core::clone::Clone for PATHNAME_BUFFER {
4454     fn clone(&self) -> Self {
4455         *self
4456     }
4457 }
4458 #[repr(C)]
4459 pub struct PERF_BIN {
4460     pub NumberOfBins: u32,
4461     pub TypeOfBin: u32,
4462     pub BinsRanges: [BIN_RANGE; 1],
4463 }
4464 impl ::core::marker::Copy for PERF_BIN {}
4465 impl ::core::clone::Clone for PERF_BIN {
4466     fn clone(&self) -> Self {
4467         *self
4468     }
4469 }
4470 #[repr(C)]
4471 pub struct PERSISTENT_RESERVE_COMMAND {
4472     pub Version: u32,
4473     pub Size: u32,
4474     pub Anonymous: PERSISTENT_RESERVE_COMMAND_0,
4475 }
4476 impl ::core::marker::Copy for PERSISTENT_RESERVE_COMMAND {}
4477 impl ::core::clone::Clone for PERSISTENT_RESERVE_COMMAND {
4478     fn clone(&self) -> Self {
4479         *self
4480     }
4481 }
4482 #[repr(C)]
4483 pub union PERSISTENT_RESERVE_COMMAND_0 {
4484     pub PR_IN: PERSISTENT_RESERVE_COMMAND_0_0,
4485     pub PR_OUT: PERSISTENT_RESERVE_COMMAND_0_1,
4486 }
4487 impl ::core::marker::Copy for PERSISTENT_RESERVE_COMMAND_0 {}
4488 impl ::core::clone::Clone for PERSISTENT_RESERVE_COMMAND_0 {
4489     fn clone(&self) -> Self {
4490         *self
4491     }
4492 }
4493 #[repr(C)]
4494 pub struct PERSISTENT_RESERVE_COMMAND_0_0 {
4495     pub _bitfield: u8,
4496     pub AllocationLength: u16,
4497 }
4498 impl ::core::marker::Copy for PERSISTENT_RESERVE_COMMAND_0_0 {}
4499 impl ::core::clone::Clone for PERSISTENT_RESERVE_COMMAND_0_0 {
4500     fn clone(&self) -> Self {
4501         *self
4502     }
4503 }
4504 #[repr(C)]
4505 pub struct PERSISTENT_RESERVE_COMMAND_0_1 {
4506     pub _bitfield1: u8,
4507     pub _bitfield2: u8,
4508     pub ParameterList: [u8; 1],
4509 }
4510 impl ::core::marker::Copy for PERSISTENT_RESERVE_COMMAND_0_1 {}
4511 impl ::core::clone::Clone for PERSISTENT_RESERVE_COMMAND_0_1 {
4512     fn clone(&self) -> Self {
4513         *self
4514     }
4515 }
4516 pub const PERSISTENT_VOLUME_STATE_BACKED_BY_WIM: u32 = 64u32;
4517 pub const PERSISTENT_VOLUME_STATE_CHKDSK_RAN_ONCE: u32 = 1024u32;
4518 pub const PERSISTENT_VOLUME_STATE_CONTAINS_BACKING_WIM: u32 = 32u32;
4519 pub const PERSISTENT_VOLUME_STATE_DAX_FORMATTED: u32 = 4096u32;
4520 pub const PERSISTENT_VOLUME_STATE_GLOBAL_METADATA_NO_SEEK_PENALTY: u32 = 4u32;
4521 pub const PERSISTENT_VOLUME_STATE_LOCAL_METADATA_NO_SEEK_PENALTY: u32 = 8u32;
4522 pub const PERSISTENT_VOLUME_STATE_MODIFIED_BY_CHKDSK: u32 = 2048u32;
4523 pub const PERSISTENT_VOLUME_STATE_NO_HEAT_GATHERING: u32 = 16u32;
4524 pub const PERSISTENT_VOLUME_STATE_NO_WRITE_AUTO_TIERING: u32 = 128u32;
4525 pub const PERSISTENT_VOLUME_STATE_REALLOCATE_ALL_DATA_WRITES: u32 = 512u32;
4526 pub const PERSISTENT_VOLUME_STATE_SHORT_NAME_CREATION_DISABLED: u32 = 1u32;
4527 pub const PERSISTENT_VOLUME_STATE_TXF_DISABLED: u32 = 256u32;
4528 pub const PERSISTENT_VOLUME_STATE_VOLUME_SCRUB_DISABLED: u32 = 2u32;
4529 #[repr(C)]
4530 pub struct PHYSICAL_ELEMENT_STATUS {
4531     pub Version: u32,
4532     pub Size: u32,
4533     pub DescriptorCount: u32,
4534     pub ReturnedDescriptorCount: u32,
4535     pub ElementIdentifierBeingDepoped: u32,
4536     pub Reserved: u32,
4537     pub Descriptors: [PHYSICAL_ELEMENT_STATUS_DESCRIPTOR; 1],
4538 }
4539 impl ::core::marker::Copy for PHYSICAL_ELEMENT_STATUS {}
4540 impl ::core::clone::Clone for PHYSICAL_ELEMENT_STATUS {
4541     fn clone(&self) -> Self {
4542         *self
4543     }
4544 }
4545 #[repr(C)]
4546 pub struct PHYSICAL_ELEMENT_STATUS_DESCRIPTOR {
4547     pub Version: u32,
4548     pub Size: u32,
4549     pub ElementIdentifier: u32,
4550     pub PhysicalElementType: u8,
4551     pub PhysicalElementHealth: u8,
4552     pub Reserved1: [u8; 2],
4553     pub AssociatedCapacity: u64,
4554     pub Reserved2: [u32; 4],
4555 }
4556 impl ::core::marker::Copy for PHYSICAL_ELEMENT_STATUS_DESCRIPTOR {}
4557 impl ::core::clone::Clone for PHYSICAL_ELEMENT_STATUS_DESCRIPTOR {
4558     fn clone(&self) -> Self {
4559         *self
4560     }
4561 }
4562 #[repr(C)]
4563 pub struct PHYSICAL_ELEMENT_STATUS_REQUEST {
4564     pub Version: u32,
4565     pub Size: u32,
4566     pub StartingElement: u32,
4567     pub Filter: u8,
4568     pub ReportType: u8,
4569     pub Reserved: [u8; 2],
4570 }
4571 impl ::core::marker::Copy for PHYSICAL_ELEMENT_STATUS_REQUEST {}
4572 impl ::core::clone::Clone for PHYSICAL_ELEMENT_STATUS_REQUEST {
4573     fn clone(&self) -> Self {
4574         *self
4575     }
4576 }
4577 pub type PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK = unsafe extern "system" fn(sourcecontext: *const IO_IRP_EXT_TRACK_OFFSET_HEADER, targetcontext: *mut IO_IRP_EXT_TRACK_OFFSET_HEADER, relativeoffset: i64);
4578 #[repr(C)]
4579 pub struct PLEX_READ_DATA_REQUEST {
4580     pub ByteOffset: i64,
4581     pub ByteLength: u32,
4582     pub PlexNumber: u32,
4583 }
4584 impl ::core::marker::Copy for PLEX_READ_DATA_REQUEST {}
4585 impl ::core::clone::Clone for PLEX_READ_DATA_REQUEST {
4586     fn clone(&self) -> Self {
4587         *self
4588     }
4589 }
4590 #[repr(C)]
4591 #[cfg(feature = "Win32_Foundation")]
4592 pub struct PREVENT_MEDIA_REMOVAL {
4593     pub PreventMediaRemoval: super::super::Foundation::BOOLEAN,
4594 }
4595 #[cfg(feature = "Win32_Foundation")]
4596 impl ::core::marker::Copy for PREVENT_MEDIA_REMOVAL {}
4597 #[cfg(feature = "Win32_Foundation")]
4598 impl ::core::clone::Clone for PREVENT_MEDIA_REMOVAL {
4599     fn clone(&self) -> Self {
4600         *self
4601     }
4602 }
4603 pub const PRODUCT_ID_LENGTH: u32 = 16u32;
4604 pub const PROJFS_PROTOCOL_VERSION: u32 = 3u32;
4605 #[repr(C)]
4606 pub struct QUERY_BAD_RANGES_INPUT {
4607     pub Flags: u32,
4608     pub NumRanges: u32,
4609     pub Ranges: [QUERY_BAD_RANGES_INPUT_RANGE; 1],
4610 }
4611 impl ::core::marker::Copy for QUERY_BAD_RANGES_INPUT {}
4612 impl ::core::clone::Clone for QUERY_BAD_RANGES_INPUT {
4613     fn clone(&self) -> Self {
4614         *self
4615     }
4616 }
4617 #[repr(C)]
4618 pub struct QUERY_BAD_RANGES_INPUT_RANGE {
4619     pub StartOffset: u64,
4620     pub LengthInBytes: u64,
4621 }
4622 impl ::core::marker::Copy for QUERY_BAD_RANGES_INPUT_RANGE {}
4623 impl ::core::clone::Clone for QUERY_BAD_RANGES_INPUT_RANGE {
4624     fn clone(&self) -> Self {
4625         *self
4626     }
4627 }
4628 #[repr(C)]
4629 pub struct QUERY_BAD_RANGES_OUTPUT {
4630     pub Flags: u32,
4631     pub NumBadRanges: u32,
4632     pub NextOffsetToLookUp: u64,
4633     pub BadRanges: [QUERY_BAD_RANGES_OUTPUT_RANGE; 1],
4634 }
4635 impl ::core::marker::Copy for QUERY_BAD_RANGES_OUTPUT {}
4636 impl ::core::clone::Clone for QUERY_BAD_RANGES_OUTPUT {
4637     fn clone(&self) -> Self {
4638         *self
4639     }
4640 }
4641 #[repr(C)]
4642 pub struct QUERY_BAD_RANGES_OUTPUT_RANGE {
4643     pub Flags: u32,
4644     pub Reserved: u32,
4645     pub StartOffset: u64,
4646     pub LengthInBytes: u64,
4647 }
4648 impl ::core::marker::Copy for QUERY_BAD_RANGES_OUTPUT_RANGE {}
4649 impl ::core::clone::Clone for QUERY_BAD_RANGES_OUTPUT_RANGE {
4650     fn clone(&self) -> Self {
4651         *self
4652     }
4653 }
4654 pub const QUERY_DEPENDENT_VOLUME_REQUEST_FLAG_GUEST_VOLUMES: u32 = 2u32;
4655 pub const QUERY_DEPENDENT_VOLUME_REQUEST_FLAG_HOST_VOLUMES: u32 = 1u32;
4656 pub type QUERY_FILE_LAYOUT_FILTER_TYPE = i32;
4657 pub const QUERY_FILE_LAYOUT_FILTER_TYPE_NONE: QUERY_FILE_LAYOUT_FILTER_TYPE = 0i32;
4658 pub const QUERY_FILE_LAYOUT_FILTER_TYPE_CLUSTERS: QUERY_FILE_LAYOUT_FILTER_TYPE = 1i32;
4659 pub const QUERY_FILE_LAYOUT_FILTER_TYPE_FILEID: QUERY_FILE_LAYOUT_FILTER_TYPE = 2i32;
4660 pub const QUERY_FILE_LAYOUT_FILTER_TYPE_STORAGE_RESERVE_ID: QUERY_FILE_LAYOUT_FILTER_TYPE = 3i32;
4661 pub const QUERY_FILE_LAYOUT_NUM_FILTER_TYPES: QUERY_FILE_LAYOUT_FILTER_TYPE = 4i32;
4662 pub const QUERY_FILE_LAYOUT_INCLUDE_EXTENTS: u32 = 8u32;
4663 pub const QUERY_FILE_LAYOUT_INCLUDE_EXTRA_INFO: u32 = 16u32;
4664 pub const QUERY_FILE_LAYOUT_INCLUDE_FILES_WITH_DSC_ATTRIBUTE: u32 = 4096u32;
4665 pub const QUERY_FILE_LAYOUT_INCLUDE_FULL_PATH_IN_NAMES: u32 = 64u32;
4666 pub const QUERY_FILE_LAYOUT_INCLUDE_NAMES: u32 = 2u32;
4667 pub const QUERY_FILE_LAYOUT_INCLUDE_ONLY_FILES_WITH_SPECIFIC_ATTRIBUTES: u32 = 2048u32;
4668 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAMS: u32 = 4u32;
4669 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAMS_WITH_NO_CLUSTERS_ALLOCATED: u32 = 32u32;
4670 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION: u32 = 128u32;
4671 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_DATA_ATTRIBUTE: u32 = 8192u32;
4672 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_DSC_ATTRIBUTE: u32 = 256u32;
4673 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_EA_ATTRIBUTE: u32 = 32768u32;
4674 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_EFS_ATTRIBUTE: u32 = 1024u32;
4675 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_REPARSE_ATTRIBUTE: u32 = 16384u32;
4676 pub const QUERY_FILE_LAYOUT_INCLUDE_STREAM_INFORMATION_FOR_TXF_ATTRIBUTE: u32 = 512u32;
4677 #[repr(C)]
4678 pub struct QUERY_FILE_LAYOUT_INPUT {
4679     pub Anonymous: QUERY_FILE_LAYOUT_INPUT_0,
4680     pub Flags: u32,
4681     pub FilterType: QUERY_FILE_LAYOUT_FILTER_TYPE,
4682     pub Reserved: u32,
4683     pub Filter: QUERY_FILE_LAYOUT_INPUT_1,
4684 }
4685 impl ::core::marker::Copy for QUERY_FILE_LAYOUT_INPUT {}
4686 impl ::core::clone::Clone for QUERY_FILE_LAYOUT_INPUT {
4687     fn clone(&self) -> Self {
4688         *self
4689     }
4690 }
4691 #[repr(C)]
4692 pub union QUERY_FILE_LAYOUT_INPUT_0 {
4693     pub FilterEntryCount: u32,
4694     pub NumberOfPairs: u32,
4695 }
4696 impl ::core::marker::Copy for QUERY_FILE_LAYOUT_INPUT_0 {}
4697 impl ::core::clone::Clone for QUERY_FILE_LAYOUT_INPUT_0 {
4698     fn clone(&self) -> Self {
4699         *self
4700     }
4701 }
4702 #[repr(C)]
4703 pub union QUERY_FILE_LAYOUT_INPUT_1 {
4704     pub ClusterRanges: [CLUSTER_RANGE; 1],
4705     pub FileReferenceRanges: [FILE_REFERENCE_RANGE; 1],
4706     pub StorageReserveIds: [STORAGE_RESERVE_ID; 1],
4707 }
4708 impl ::core::marker::Copy for QUERY_FILE_LAYOUT_INPUT_1 {}
4709 impl ::core::clone::Clone for QUERY_FILE_LAYOUT_INPUT_1 {
4710     fn clone(&self) -> Self {
4711         *self
4712     }
4713 }
4714 #[repr(C)]
4715 pub struct QUERY_FILE_LAYOUT_OUTPUT {
4716     pub FileEntryCount: u32,
4717     pub FirstFileOffset: u32,
4718     pub Flags: u32,
4719     pub Reserved: u32,
4720 }
4721 impl ::core::marker::Copy for QUERY_FILE_LAYOUT_OUTPUT {}
4722 impl ::core::clone::Clone for QUERY_FILE_LAYOUT_OUTPUT {
4723     fn clone(&self) -> Self {
4724         *self
4725     }
4726 }
4727 pub const QUERY_FILE_LAYOUT_REPARSE_DATA_INVALID: u32 = 1u32;
4728 pub const QUERY_FILE_LAYOUT_REPARSE_TAG_INVALID: u32 = 2u32;
4729 pub const QUERY_FILE_LAYOUT_RESTART: u32 = 1u32;
4730 pub const QUERY_FILE_LAYOUT_SINGLE_INSTANCED: u32 = 1u32;
4731 pub const QUERY_STORAGE_CLASSES_FLAGS_MEASURE_READ: u32 = 1073741824u32;
4732 pub const QUERY_STORAGE_CLASSES_FLAGS_MEASURE_WRITE: u32 = 2147483648u32;
4733 pub const QUERY_STORAGE_CLASSES_FLAGS_NO_DEFRAG_VOLUME: u32 = 536870912u32;
4734 pub const READ_ATTRIBUTES: u32 = 208u32;
4735 pub const READ_ATTRIBUTE_BUFFER_SIZE: u32 = 512u32;
4736 pub const READ_COMPRESSION_INFO_VALID: u32 = 32u32;
4737 pub const READ_COPY_NUMBER_BYPASS_CACHE_FLAG: u32 = 256u32;
4738 pub const READ_COPY_NUMBER_KEY: u32 = 1380142592u32;
4739 #[repr(C)]
4740 pub struct READ_ELEMENT_ADDRESS_INFO {
4741     pub NumberOfElements: u32,
4742     pub ElementStatus: [CHANGER_ELEMENT_STATUS; 1],
4743 }
4744 impl ::core::marker::Copy for READ_ELEMENT_ADDRESS_INFO {}
4745 impl ::core::clone::Clone for READ_ELEMENT_ADDRESS_INFO {
4746     fn clone(&self) -> Self {
4747         *self
4748     }
4749 }
4750 #[repr(C)]
4751 pub struct READ_FILE_USN_DATA {
4752     pub MinMajorVersion: u16,
4753     pub MaxMajorVersion: u16,
4754 }
4755 impl ::core::marker::Copy for READ_FILE_USN_DATA {}
4756 impl ::core::clone::Clone for READ_FILE_USN_DATA {
4757     fn clone(&self) -> Self {
4758         *self
4759     }
4760 }
4761 pub const READ_THRESHOLDS: u32 = 209u32;
4762 pub const READ_THRESHOLD_BUFFER_SIZE: u32 = 512u32;
4763 #[repr(C)]
4764 pub struct READ_USN_JOURNAL_DATA_V0 {
4765     pub StartUsn: i64,
4766     pub ReasonMask: u32,
4767     pub ReturnOnlyOnClose: u32,
4768     pub Timeout: u64,
4769     pub BytesToWaitFor: u64,
4770     pub UsnJournalID: u64,
4771 }
4772 impl ::core::marker::Copy for READ_USN_JOURNAL_DATA_V0 {}
4773 impl ::core::clone::Clone for READ_USN_JOURNAL_DATA_V0 {
4774     fn clone(&self) -> Self {
4775         *self
4776     }
4777 }
4778 #[repr(C)]
4779 pub struct READ_USN_JOURNAL_DATA_V1 {
4780     pub StartUsn: i64,
4781     pub ReasonMask: u32,
4782     pub ReturnOnlyOnClose: u32,
4783     pub Timeout: u64,
4784     pub BytesToWaitFor: u64,
4785     pub UsnJournalID: u64,
4786     pub MinMajorVersion: u16,
4787     pub MaxMajorVersion: u16,
4788 }
4789 impl ::core::marker::Copy for READ_USN_JOURNAL_DATA_V1 {}
4790 impl ::core::clone::Clone for READ_USN_JOURNAL_DATA_V1 {
4791     fn clone(&self) -> Self {
4792         *self
4793     }
4794 }
4795 #[repr(C)]
4796 pub struct REASSIGN_BLOCKS {
4797     pub Reserved: u16,
4798     pub Count: u16,
4799     pub BlockNumber: [u32; 1],
4800 }
4801 impl ::core::marker::Copy for REASSIGN_BLOCKS {}
4802 impl ::core::clone::Clone for REASSIGN_BLOCKS {
4803     fn clone(&self) -> Self {
4804         *self
4805     }
4806 }
4807 #[repr(C, packed(1))]
4808 pub struct REASSIGN_BLOCKS_EX {
4809     pub Reserved: u16,
4810     pub Count: u16,
4811     pub BlockNumber: [i64; 1],
4812 }
4813 impl ::core::marker::Copy for REASSIGN_BLOCKS_EX {}
4814 impl ::core::clone::Clone for REASSIGN_BLOCKS_EX {
4815     fn clone(&self) -> Self {
4816         *self
4817     }
4818 }
4819 pub const RECOVERED_READS_VALID: u32 = 4u32;
4820 pub const RECOVERED_WRITES_VALID: u32 = 1u32;
4821 pub type REFS_SMR_VOLUME_GC_ACTION = i32;
4822 pub const SmrGcActionStart: REFS_SMR_VOLUME_GC_ACTION = 1i32;
4823 pub const SmrGcActionStartFullSpeed: REFS_SMR_VOLUME_GC_ACTION = 2i32;
4824 pub const SmrGcActionPause: REFS_SMR_VOLUME_GC_ACTION = 3i32;
4825 pub const SmrGcActionStop: REFS_SMR_VOLUME_GC_ACTION = 4i32;
4826 pub type REFS_SMR_VOLUME_GC_METHOD = i32;
4827 pub const SmrGcMethodCompaction: REFS_SMR_VOLUME_GC_METHOD = 1i32;
4828 pub const SmrGcMethodCompression: REFS_SMR_VOLUME_GC_METHOD = 2i32;
4829 pub const SmrGcMethodRotation: REFS_SMR_VOLUME_GC_METHOD = 3i32;
4830 #[repr(C)]
4831 pub struct REFS_SMR_VOLUME_GC_PARAMETERS {
4832     pub Version: u32,
4833     pub Flags: u32,
4834     pub Action: REFS_SMR_VOLUME_GC_ACTION,
4835     pub Method: REFS_SMR_VOLUME_GC_METHOD,
4836     pub IoGranularity: u32,
4837     pub CompressionFormat: u32,
4838     pub Unused: [u64; 8],
4839 }
4840 impl ::core::marker::Copy for REFS_SMR_VOLUME_GC_PARAMETERS {}
4841 impl ::core::clone::Clone for REFS_SMR_VOLUME_GC_PARAMETERS {
4842     fn clone(&self) -> Self {
4843         *self
4844     }
4845 }
4846 pub const REFS_SMR_VOLUME_GC_PARAMETERS_VERSION_V1: u32 = 1u32;
4847 pub type REFS_SMR_VOLUME_GC_STATE = i32;
4848 pub const SmrGcStateInactive: REFS_SMR_VOLUME_GC_STATE = 0i32;
4849 pub const SmrGcStatePaused: REFS_SMR_VOLUME_GC_STATE = 1i32;
4850 pub const SmrGcStateActive: REFS_SMR_VOLUME_GC_STATE = 2i32;
4851 pub const SmrGcStateActiveFullSpeed: REFS_SMR_VOLUME_GC_STATE = 3i32;
4852 #[repr(C)]
4853 pub struct REFS_SMR_VOLUME_INFO_OUTPUT {
4854     pub Version: u32,
4855     pub Flags: u32,
4856     pub SizeOfRandomlyWritableTier: i64,
4857     pub FreeSpaceInRandomlyWritableTier: i64,
4858     pub SizeofSMRTier: i64,
4859     pub FreeSpaceInSMRTier: i64,
4860     pub UsableFreeSpaceInSMRTier: i64,
4861     pub VolumeGcState: REFS_SMR_VOLUME_GC_STATE,
4862     pub VolumeGcLastStatus: u32,
4863     pub CurrentGcBandFillPercentage: u32,
4864     pub Unused: [u64; 6],
4865 }
4866 impl ::core::marker::Copy for REFS_SMR_VOLUME_INFO_OUTPUT {}
4867 impl ::core::clone::Clone for REFS_SMR_VOLUME_INFO_OUTPUT {
4868     fn clone(&self) -> Self {
4869         *self
4870     }
4871 }
4872 pub const REFS_SMR_VOLUME_INFO_OUTPUT_VERSION_V0: u32 = 0u32;
4873 pub const REFS_SMR_VOLUME_INFO_OUTPUT_VERSION_V1: u32 = 1u32;
4874 #[repr(C)]
4875 pub struct REFS_VOLUME_DATA_BUFFER {
4876     pub ByteCount: u32,
4877     pub MajorVersion: u32,
4878     pub MinorVersion: u32,
4879     pub BytesPerPhysicalSector: u32,
4880     pub VolumeSerialNumber: i64,
4881     pub NumberSectors: i64,
4882     pub TotalClusters: i64,
4883     pub FreeClusters: i64,
4884     pub TotalReserved: i64,
4885     pub BytesPerSector: u32,
4886     pub BytesPerCluster: u32,
4887     pub MaximumSizeOfResidentFile: i64,
4888     pub FastTierDataFillRatio: u16,
4889     pub SlowTierDataFillRatio: u16,
4890     pub DestagesFastTierToSlowTierRate: u32,
4891     pub Reserved: [i64; 9],
4892 }
4893 impl ::core::marker::Copy for REFS_VOLUME_DATA_BUFFER {}
4894 impl ::core::clone::Clone for REFS_VOLUME_DATA_BUFFER {
4895     fn clone(&self) -> Self {
4896         *self
4897     }
4898 }
4899 #[repr(C)]
4900 pub struct REMOVE_ELEMENT_AND_TRUNCATE_REQUEST {
4901     pub Version: u32,
4902     pub Size: u32,
4903     pub RequestCapacity: u64,
4904     pub ElementIdentifier: u32,
4905     pub Reserved: u32,
4906 }
4907 impl ::core::marker::Copy for REMOVE_ELEMENT_AND_TRUNCATE_REQUEST {}
4908 impl ::core::clone::Clone for REMOVE_ELEMENT_AND_TRUNCATE_REQUEST {
4909     fn clone(&self) -> Self {
4910         *self
4911     }
4912 }
4913 #[repr(C)]
4914 pub struct REPAIR_COPIES_INPUT {
4915     pub Size: u32,
4916     pub Flags: u32,
4917     pub FileOffset: i64,
4918     pub Length: u32,
4919     pub SourceCopy: u32,
4920     pub NumberOfRepairCopies: u32,
4921     pub RepairCopies: [u32; 1],
4922 }
4923 impl ::core::marker::Copy for REPAIR_COPIES_INPUT {}
4924 impl ::core::clone::Clone for REPAIR_COPIES_INPUT {
4925     fn clone(&self) -> Self {
4926         *self
4927     }
4928 }
4929 #[repr(C)]
4930 pub struct REPAIR_COPIES_OUTPUT {
4931     pub Size: u32,
4932     pub Status: u32,
4933     pub ResumeFileOffset: i64,
4934 }
4935 impl ::core::marker::Copy for REPAIR_COPIES_OUTPUT {}
4936 impl ::core::clone::Clone for REPAIR_COPIES_OUTPUT {
4937     fn clone(&self) -> Self {
4938         *self
4939     }
4940 }
4941 pub const REPLACE_ALTERNATE: u32 = 11u32;
4942 pub const REPLACE_PRIMARY: u32 = 10u32;
4943 pub const REQUEST_OPLOCK_CURRENT_VERSION: u32 = 1u32;
4944 #[repr(C)]
4945 pub struct REQUEST_OPLOCK_INPUT_BUFFER {
4946     pub StructureVersion: u16,
4947     pub StructureLength: u16,
4948     pub RequestedOplockLevel: u32,
4949     pub Flags: u32,
4950 }
4951 impl ::core::marker::Copy for REQUEST_OPLOCK_INPUT_BUFFER {}
4952 impl ::core::clone::Clone for REQUEST_OPLOCK_INPUT_BUFFER {
4953     fn clone(&self) -> Self {
4954         *self
4955     }
4956 }
4957 pub const REQUEST_OPLOCK_INPUT_FLAG_ACK: u32 = 2u32;
4958 pub const REQUEST_OPLOCK_INPUT_FLAG_COMPLETE_ACK_ON_CLOSE: u32 = 4u32;
4959 pub const REQUEST_OPLOCK_INPUT_FLAG_REQUEST: u32 = 1u32;
4960 #[repr(C)]
4961 pub struct REQUEST_OPLOCK_OUTPUT_BUFFER {
4962     pub StructureVersion: u16,
4963     pub StructureLength: u16,
4964     pub OriginalOplockLevel: u32,
4965     pub NewOplockLevel: u32,
4966     pub Flags: u32,
4967     pub AccessMode: u32,
4968     pub ShareMode: u16,
4969 }
4970 impl ::core::marker::Copy for REQUEST_OPLOCK_OUTPUT_BUFFER {}
4971 impl ::core::clone::Clone for REQUEST_OPLOCK_OUTPUT_BUFFER {
4972     fn clone(&self) -> Self {
4973         *self
4974     }
4975 }
4976 pub const REQUEST_OPLOCK_OUTPUT_FLAG_ACK_REQUIRED: u32 = 1u32;
4977 pub const REQUEST_OPLOCK_OUTPUT_FLAG_MODES_PROVIDED: u32 = 2u32;
4978 #[repr(C)]
4979 pub struct REQUEST_RAW_ENCRYPTED_DATA {
4980     pub FileOffset: i64,
4981     pub Length: u32,
4982 }
4983 impl ::core::marker::Copy for REQUEST_RAW_ENCRYPTED_DATA {}
4984 impl ::core::clone::Clone for REQUEST_RAW_ENCRYPTED_DATA {
4985     fn clone(&self) -> Self {
4986         *self
4987     }
4988 }
4989 pub const RETRACT_IEPORT: u32 = 3u32;
4990 #[repr(C)]
4991 pub struct RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER {
4992     pub ExtentCount: u32,
4993     pub StartingVcn: i64,
4994     pub Extents: [RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER_0; 1],
4995 }
4996 impl ::core::marker::Copy for RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER {}
4997 impl ::core::clone::Clone for RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER {
4998     fn clone(&self) -> Self {
4999         *self
5000     }
5001 }
5002 #[repr(C)]
5003 pub struct RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER_0 {
5004     pub NextVcn: i64,
5005     pub Lcn: i64,
5006     pub ReferenceCount: u32,
5007 }
5008 impl ::core::marker::Copy for RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER_0 {}
5009 impl ::core::clone::Clone for RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER_0 {
5010     fn clone(&self) -> Self {
5011         *self
5012     }
5013 }
5014 #[repr(C)]
5015 pub struct RETRIEVAL_POINTERS_BUFFER {
5016     pub ExtentCount: u32,
5017     pub StartingVcn: i64,
5018     pub Extents: [RETRIEVAL_POINTERS_BUFFER_0; 1],
5019 }
5020 impl ::core::marker::Copy for RETRIEVAL_POINTERS_BUFFER {}
5021 impl ::core::clone::Clone for RETRIEVAL_POINTERS_BUFFER {
5022     fn clone(&self) -> Self {
5023         *self
5024     }
5025 }
5026 #[repr(C)]
5027 pub struct RETRIEVAL_POINTERS_BUFFER_0 {
5028     pub NextVcn: i64,
5029     pub Lcn: i64,
5030 }
5031 impl ::core::marker::Copy for RETRIEVAL_POINTERS_BUFFER_0 {}
5032 impl ::core::clone::Clone for RETRIEVAL_POINTERS_BUFFER_0 {
5033     fn clone(&self) -> Self {
5034         *self
5035     }
5036 }
5037 #[repr(C)]
5038 pub struct RETRIEVAL_POINTER_BASE {
5039     pub FileAreaOffset: i64,
5040 }
5041 impl ::core::marker::Copy for RETRIEVAL_POINTER_BASE {}
5042 impl ::core::clone::Clone for RETRIEVAL_POINTER_BASE {
5043     fn clone(&self) -> Self {
5044         *self
5045     }
5046 }
5047 #[repr(C)]
5048 pub struct RETRIEVAL_POINTER_COUNT {
5049     pub ExtentCount: u32,
5050 }
5051 impl ::core::marker::Copy for RETRIEVAL_POINTER_COUNT {}
5052 impl ::core::clone::Clone for RETRIEVAL_POINTER_COUNT {
5053     fn clone(&self) -> Self {
5054         *self
5055     }
5056 }
5057 pub const RETURN_SMART_STATUS: u32 = 218u32;
5058 pub const REVISION_LENGTH: u32 = 4u32;
5059 pub const SAVE_ATTRIBUTE_VALUES: u32 = 211u32;
5060 #[repr(C)]
5061 pub struct SCM_BUS_DEDICATED_MEMORY_DEVICES_INFO {
5062     pub Version: u32,
5063     pub Size: u32,
5064     pub DeviceCount: u32,
5065     pub Devices: [SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO; 1],
5066 }
5067 impl ::core::marker::Copy for SCM_BUS_DEDICATED_MEMORY_DEVICES_INFO {}
5068 impl ::core::clone::Clone for SCM_BUS_DEDICATED_MEMORY_DEVICES_INFO {
5069     fn clone(&self) -> Self {
5070         *self
5071     }
5072 }
5073 #[repr(C)]
5074 pub struct SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO {
5075     pub DeviceGuid: ::windows_sys::core::GUID,
5076     pub DeviceNumber: u32,
5077     pub Flags: SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO_0,
5078     pub DeviceSize: u64,
5079 }
5080 impl ::core::marker::Copy for SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO {}
5081 impl ::core::clone::Clone for SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO {
5082     fn clone(&self) -> Self {
5083         *self
5084     }
5085 }
5086 #[repr(C)]
5087 pub struct SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO_0 {
5088     pub _bitfield: u32,
5089 }
5090 impl ::core::marker::Copy for SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO_0 {}
5091 impl ::core::clone::Clone for SCM_BUS_DEDICATED_MEMORY_DEVICE_INFO_0 {
5092     fn clone(&self) -> Self {
5093         *self
5094     }
5095 }
5096 #[repr(C)]
5097 #[cfg(feature = "Win32_Foundation")]
5098 pub struct SCM_BUS_DEDICATED_MEMORY_STATE {
5099     pub ActivateState: super::super::Foundation::BOOLEAN,
5100 }
5101 #[cfg(feature = "Win32_Foundation")]
5102 impl ::core::marker::Copy for SCM_BUS_DEDICATED_MEMORY_STATE {}
5103 #[cfg(feature = "Win32_Foundation")]
5104 impl ::core::clone::Clone for SCM_BUS_DEDICATED_MEMORY_STATE {
5105     fn clone(&self) -> Self {
5106         *self
5107     }
5108 }
5109 pub type SCM_BUS_FIRMWARE_ACTIVATION_STATE = i32;
5110 pub const ScmBusFirmwareActivationState_Idle: SCM_BUS_FIRMWARE_ACTIVATION_STATE = 0i32;
5111 pub const ScmBusFirmwareActivationState_Armed: SCM_BUS_FIRMWARE_ACTIVATION_STATE = 1i32;
5112 pub const ScmBusFirmwareActivationState_Busy: SCM_BUS_FIRMWARE_ACTIVATION_STATE = 2i32;
5113 pub type SCM_BUS_PROPERTY_ID = i32;
5114 pub const ScmBusProperty_RuntimeFwActivationInfo: SCM_BUS_PROPERTY_ID = 0i32;
5115 pub const ScmBusProperty_DedicatedMemoryInfo: SCM_BUS_PROPERTY_ID = 1i32;
5116 pub const ScmBusProperty_DedicatedMemoryState: SCM_BUS_PROPERTY_ID = 2i32;
5117 pub const ScmBusProperty_Max: SCM_BUS_PROPERTY_ID = 3i32;
5118 #[repr(C)]
5119 pub struct SCM_BUS_PROPERTY_QUERY {
5120     pub Version: u32,
5121     pub Size: u32,
5122     pub PropertyId: SCM_BUS_PROPERTY_ID,
5123     pub QueryType: SCM_BUS_QUERY_TYPE,
5124     pub AdditionalParameters: [u8; 1],
5125 }
5126 impl ::core::marker::Copy for SCM_BUS_PROPERTY_QUERY {}
5127 impl ::core::clone::Clone for SCM_BUS_PROPERTY_QUERY {
5128     fn clone(&self) -> Self {
5129         *self
5130     }
5131 }
5132 #[repr(C)]
5133 pub struct SCM_BUS_PROPERTY_SET {
5134     pub Version: u32,
5135     pub Size: u32,
5136     pub PropertyId: SCM_BUS_PROPERTY_ID,
5137     pub SetType: SCM_BUS_SET_TYPE,
5138     pub AdditionalParameters: [u8; 1],
5139 }
5140 impl ::core::marker::Copy for SCM_BUS_PROPERTY_SET {}
5141 impl ::core::clone::Clone for SCM_BUS_PROPERTY_SET {
5142     fn clone(&self) -> Self {
5143         *self
5144     }
5145 }
5146 pub type SCM_BUS_QUERY_TYPE = i32;
5147 pub const ScmBusQuery_Descriptor: SCM_BUS_QUERY_TYPE = 0i32;
5148 pub const ScmBusQuery_IsSupported: SCM_BUS_QUERY_TYPE = 1i32;
5149 pub const ScmBusQuery_Max: SCM_BUS_QUERY_TYPE = 2i32;
5150 #[repr(C)]
5151 #[cfg(feature = "Win32_Foundation")]
5152 pub struct SCM_BUS_RUNTIME_FW_ACTIVATION_INFO {
5153     pub Version: u32,
5154     pub Size: u32,
5155     pub RuntimeFwActivationSupported: super::super::Foundation::BOOLEAN,
5156     pub FirmwareActivationState: SCM_BUS_FIRMWARE_ACTIVATION_STATE,
5157     pub FirmwareActivationCapability: SCM_BUS_RUNTIME_FW_ACTIVATION_INFO_0,
5158     pub EstimatedFirmwareActivationTimeInUSecs: u64,
5159     pub EstimatedProcessorAccessQuiesceTimeInUSecs: u64,
5160     pub EstimatedIOAccessQuiesceTimeInUSecs: u64,
5161     pub PlatformSupportedMaxIOAccessQuiesceTimeInUSecs: u64,
5162 }
5163 #[cfg(feature = "Win32_Foundation")]
5164 impl ::core::marker::Copy for SCM_BUS_RUNTIME_FW_ACTIVATION_INFO {}
5165 #[cfg(feature = "Win32_Foundation")]
5166 impl ::core::clone::Clone for SCM_BUS_RUNTIME_FW_ACTIVATION_INFO {
5167     fn clone(&self) -> Self {
5168         *self
5169     }
5170 }
5171 #[repr(C)]
5172 #[cfg(feature = "Win32_Foundation")]
5173 pub struct SCM_BUS_RUNTIME_FW_ACTIVATION_INFO_0 {
5174     pub _bitfield: u32,
5175 }
5176 #[cfg(feature = "Win32_Foundation")]
5177 impl ::core::marker::Copy for SCM_BUS_RUNTIME_FW_ACTIVATION_INFO_0 {}
5178 #[cfg(feature = "Win32_Foundation")]
5179 impl ::core::clone::Clone for SCM_BUS_RUNTIME_FW_ACTIVATION_INFO_0 {
5180     fn clone(&self) -> Self {
5181         *self
5182     }
5183 }
5184 pub type SCM_BUS_SET_TYPE = i32;
5185 pub const ScmBusSet_Descriptor: SCM_BUS_SET_TYPE = 0i32;
5186 pub const ScmBusSet_IsSupported: SCM_BUS_SET_TYPE = 1i32;
5187 pub const ScmBusSet_Max: SCM_BUS_SET_TYPE = 2i32;
5188 #[repr(C)]
5189 pub struct SCM_INTERLEAVED_PD_INFO {
5190     pub DeviceHandle: u32,
5191     pub DeviceGuid: ::windows_sys::core::GUID,
5192 }
5193 impl ::core::marker::Copy for SCM_INTERLEAVED_PD_INFO {}
5194 impl ::core::clone::Clone for SCM_INTERLEAVED_PD_INFO {
5195     fn clone(&self) -> Self {
5196         *self
5197     }
5198 }
5199 #[repr(C)]
5200 pub struct SCM_LD_INTERLEAVE_SET_INFO {
5201     pub Version: u32,
5202     pub Size: u32,
5203     pub InterleaveSetSize: u32,
5204     pub InterleaveSet: [SCM_INTERLEAVED_PD_INFO; 1],
5205 }
5206 impl ::core::marker::Copy for SCM_LD_INTERLEAVE_SET_INFO {}
5207 impl ::core::clone::Clone for SCM_LD_INTERLEAVE_SET_INFO {
5208     fn clone(&self) -> Self {
5209         *self
5210     }
5211 }
5212 #[repr(C)]
5213 pub struct SCM_LOGICAL_DEVICES {
5214     pub Version: u32,
5215     pub Size: u32,
5216     pub DeviceCount: u32,
5217     pub Devices: [SCM_LOGICAL_DEVICE_INSTANCE; 1],
5218 }
5219 impl ::core::marker::Copy for SCM_LOGICAL_DEVICES {}
5220 impl ::core::clone::Clone for SCM_LOGICAL_DEVICES {
5221     fn clone(&self) -> Self {
5222         *self
5223     }
5224 }
5225 #[repr(C)]
5226 pub struct SCM_LOGICAL_DEVICE_INSTANCE {
5227     pub Version: u32,
5228     pub Size: u32,
5229     pub DeviceGuid: ::windows_sys::core::GUID,
5230     pub SymbolicLink: [u16; 256],
5231 }
5232 impl ::core::marker::Copy for SCM_LOGICAL_DEVICE_INSTANCE {}
5233 impl ::core::clone::Clone for SCM_LOGICAL_DEVICE_INSTANCE {
5234     fn clone(&self) -> Self {
5235         *self
5236     }
5237 }
5238 pub const SCM_MAX_SYMLINK_LEN_IN_CHARS: u32 = 256u32;
5239 #[repr(C)]
5240 pub struct SCM_PD_DESCRIPTOR_HEADER {
5241     pub Version: u32,
5242     pub Size: u32,
5243 }
5244 impl ::core::marker::Copy for SCM_PD_DESCRIPTOR_HEADER {}
5245 impl ::core::clone::Clone for SCM_PD_DESCRIPTOR_HEADER {
5246     fn clone(&self) -> Self {
5247         *self
5248     }
5249 }
5250 #[repr(C)]
5251 pub struct SCM_PD_DEVICE_HANDLE {
5252     pub Version: u32,
5253     pub Size: u32,
5254     pub DeviceGuid: ::windows_sys::core::GUID,
5255     pub DeviceHandle: u32,
5256 }
5257 impl ::core::marker::Copy for SCM_PD_DEVICE_HANDLE {}
5258 impl ::core::clone::Clone for SCM_PD_DEVICE_HANDLE {
5259     fn clone(&self) -> Self {
5260         *self
5261     }
5262 }
5263 #[repr(C)]
5264 #[cfg(feature = "Win32_Foundation")]
5265 pub struct SCM_PD_DEVICE_INFO {
5266     pub Version: u32,
5267     pub Size: u32,
5268     pub DeviceGuid: ::windows_sys::core::GUID,
5269     pub UnsafeShutdownCount: u32,
5270     pub PersistentMemorySizeInBytes: u64,
5271     pub VolatileMemorySizeInBytes: u64,
5272     pub TotalMemorySizeInBytes: u64,
5273     pub SlotNumber: u32,
5274     pub DeviceHandle: u32,
5275     pub PhysicalId: u16,
5276     pub NumberOfFormatInterfaceCodes: u8,
5277     pub FormatInterfaceCodes: [u16; 8],
5278     pub VendorId: u32,
5279     pub ProductId: u32,
5280     pub SubsystemDeviceId: u32,
5281     pub SubsystemVendorId: u32,
5282     pub ManufacturingLocation: u8,
5283     pub ManufacturingWeek: u8,
5284     pub ManufacturingYear: u8,
5285     pub SerialNumber4Byte: u32,
5286     pub SerialNumberLengthInChars: u32,
5287     pub SerialNumber: [super::super::Foundation::CHAR; 1],
5288 }
5289 #[cfg(feature = "Win32_Foundation")]
5290 impl ::core::marker::Copy for SCM_PD_DEVICE_INFO {}
5291 #[cfg(feature = "Win32_Foundation")]
5292 impl ::core::clone::Clone for SCM_PD_DEVICE_INFO {
5293     fn clone(&self) -> Self {
5294         *self
5295     }
5296 }
5297 #[repr(C)]
5298 pub struct SCM_PD_DEVICE_SPECIFIC_INFO {
5299     pub Version: u32,
5300     pub Size: u32,
5301     pub NumberOfProperties: u32,
5302     pub DeviceSpecificProperties: [SCM_PD_DEVICE_SPECIFIC_PROPERTY; 1],
5303 }
5304 impl ::core::marker::Copy for SCM_PD_DEVICE_SPECIFIC_INFO {}
5305 impl ::core::clone::Clone for SCM_PD_DEVICE_SPECIFIC_INFO {
5306     fn clone(&self) -> Self {
5307         *self
5308     }
5309 }
5310 #[repr(C)]
5311 pub struct SCM_PD_DEVICE_SPECIFIC_PROPERTY {
5312     pub Name: [u16; 128],
5313     pub Value: i64,
5314 }
5315 impl ::core::marker::Copy for SCM_PD_DEVICE_SPECIFIC_PROPERTY {}
5316 impl ::core::clone::Clone for SCM_PD_DEVICE_SPECIFIC_PROPERTY {
5317     fn clone(&self) -> Self {
5318         *self
5319     }
5320 }
5321 #[repr(C)]
5322 pub struct SCM_PD_FIRMWARE_ACTIVATE {
5323     pub Version: u32,
5324     pub Size: u32,
5325     pub Flags: u32,
5326     pub Slot: u8,
5327 }
5328 impl ::core::marker::Copy for SCM_PD_FIRMWARE_ACTIVATE {}
5329 impl ::core::clone::Clone for SCM_PD_FIRMWARE_ACTIVATE {
5330     fn clone(&self) -> Self {
5331         *self
5332     }
5333 }
5334 pub type SCM_PD_FIRMWARE_ACTIVATION_STATE = i32;
5335 pub const ScmPdFirmwareActivationState_Idle: SCM_PD_FIRMWARE_ACTIVATION_STATE = 0i32;
5336 pub const ScmPdFirmwareActivationState_Armed: SCM_PD_FIRMWARE_ACTIVATION_STATE = 1i32;
5337 pub const ScmPdFirmwareActivationState_Busy: SCM_PD_FIRMWARE_ACTIVATION_STATE = 2i32;
5338 #[repr(C)]
5339 pub struct SCM_PD_FIRMWARE_DOWNLOAD {
5340     pub Version: u32,
5341     pub Size: u32,
5342     pub Flags: u32,
5343     pub Slot: u8,
5344     pub Reserved: [u8; 3],
5345     pub Offset: u64,
5346     pub FirmwareImageSizeInBytes: u32,
5347     pub FirmwareImage: [u8; 1],
5348 }
5349 impl ::core::marker::Copy for SCM_PD_FIRMWARE_DOWNLOAD {}
5350 impl ::core::clone::Clone for SCM_PD_FIRMWARE_DOWNLOAD {
5351     fn clone(&self) -> Self {
5352         *self
5353     }
5354 }
5355 #[repr(C)]
5356 pub struct SCM_PD_FIRMWARE_INFO {
5357     pub Version: u32,
5358     pub Size: u32,
5359     pub ActiveSlot: u8,
5360     pub NextActiveSlot: u8,
5361     pub SlotCount: u8,
5362     pub Slots: [SCM_PD_FIRMWARE_SLOT_INFO; 1],
5363 }
5364 impl ::core::marker::Copy for SCM_PD_FIRMWARE_INFO {}
5365 impl ::core::clone::Clone for SCM_PD_FIRMWARE_INFO {
5366     fn clone(&self) -> Self {
5367         *self
5368     }
5369 }
5370 pub const SCM_PD_FIRMWARE_LAST_DOWNLOAD: u32 = 1u32;
5371 pub const SCM_PD_FIRMWARE_REVISION_LENGTH_BYTES: u32 = 32u32;
5372 #[repr(C)]
5373 pub struct SCM_PD_FIRMWARE_SLOT_INFO {
5374     pub Version: u32,
5375     pub Size: u32,
5376     pub SlotNumber: u8,
5377     pub _bitfield: u8,
5378     pub Reserved1: [u8; 6],
5379     pub Revision: [u8; 32],
5380 }
5381 impl ::core::marker::Copy for SCM_PD_FIRMWARE_SLOT_INFO {}
5382 impl ::core::clone::Clone for SCM_PD_FIRMWARE_SLOT_INFO {
5383     fn clone(&self) -> Self {
5384         *self
5385     }
5386 }
5387 #[repr(C)]
5388 pub struct SCM_PD_FRU_ID_STRING {
5389     pub Version: u32,
5390     pub Size: u32,
5391     pub IdentifierSize: u32,
5392     pub Identifier: [u8; 1],
5393 }
5394 impl ::core::marker::Copy for SCM_PD_FRU_ID_STRING {}
5395 impl ::core::clone::Clone for SCM_PD_FRU_ID_STRING {
5396     fn clone(&self) -> Self {
5397         *self
5398     }
5399 }
5400 #[repr(C)]
5401 pub struct SCM_PD_HEALTH_NOTIFICATION_DATA {
5402     pub DeviceGuid: ::windows_sys::core::GUID,
5403 }
5404 impl ::core::marker::Copy for SCM_PD_HEALTH_NOTIFICATION_DATA {}
5405 impl ::core::clone::Clone for SCM_PD_HEALTH_NOTIFICATION_DATA {
5406     fn clone(&self) -> Self {
5407         *self
5408     }
5409 }
5410 pub type SCM_PD_HEALTH_STATUS = i32;
5411 pub const ScmPhysicalDeviceHealth_Unknown: SCM_PD_HEALTH_STATUS = 0i32;
5412 pub const ScmPhysicalDeviceHealth_Unhealthy: SCM_PD_HEALTH_STATUS = 1i32;
5413 pub const ScmPhysicalDeviceHealth_Warning: SCM_PD_HEALTH_STATUS = 2i32;
5414 pub const ScmPhysicalDeviceHealth_Healthy: SCM_PD_HEALTH_STATUS = 3i32;
5415 pub const ScmPhysicalDeviceHealth_Max: SCM_PD_HEALTH_STATUS = 4i32;
5416 pub type SCM_PD_LAST_FW_ACTIVATION_STATUS = i32;
5417 pub const ScmPdLastFwActivationStatus_None: SCM_PD_LAST_FW_ACTIVATION_STATUS = 0i32;
5418 pub const ScmPdLastFwActivationStatus_Success: SCM_PD_LAST_FW_ACTIVATION_STATUS = 1i32;
5419 pub const ScmPdLastFwActivationStatus_FwNotFound: SCM_PD_LAST_FW_ACTIVATION_STATUS = 2i32;
5420 pub const ScmPdLastFwActivationStatus_ColdRebootRequired: SCM_PD_LAST_FW_ACTIVATION_STATUS = 3i32;
5421 pub const ScmPdLastFwActivaitonStatus_ActivationInProgress: SCM_PD_LAST_FW_ACTIVATION_STATUS = 4i32;
5422 pub const ScmPdLastFwActivaitonStatus_Retry: SCM_PD_LAST_FW_ACTIVATION_STATUS = 5i32;
5423 pub const ScmPdLastFwActivaitonStatus_FwUnsupported: SCM_PD_LAST_FW_ACTIVATION_STATUS = 6i32;
5424 pub const ScmPdLastFwActivaitonStatus_UnknownError: SCM_PD_LAST_FW_ACTIVATION_STATUS = 7i32;
5425 #[repr(C)]
5426 pub struct SCM_PD_LOCATION_STRING {
5427     pub Version: u32,
5428     pub Size: u32,
5429     pub Location: [u16; 1],
5430 }
5431 impl ::core::marker::Copy for SCM_PD_LOCATION_STRING {}
5432 impl ::core::clone::Clone for SCM_PD_LOCATION_STRING {
5433     fn clone(&self) -> Self {
5434         *self
5435     }
5436 }
5437 #[repr(C)]
5438 pub struct SCM_PD_MANAGEMENT_STATUS {
5439     pub Version: u32,
5440     pub Size: u32,
5441     pub Health: SCM_PD_HEALTH_STATUS,
5442     pub NumberOfOperationalStatus: u32,
5443     pub NumberOfAdditionalReasons: u32,
5444     pub OperationalStatus: [SCM_PD_OPERATIONAL_STATUS; 16],
5445     pub AdditionalReasons: [SCM_PD_OPERATIONAL_STATUS_REASON; 1],
5446 }
5447 impl ::core::marker::Copy for SCM_PD_MANAGEMENT_STATUS {}
5448 impl ::core::clone::Clone for SCM_PD_MANAGEMENT_STATUS {
5449     fn clone(&self) -> Self {
5450         *self
5451     }
5452 }
5453 pub const SCM_PD_MAX_OPERATIONAL_STATUS: u32 = 16u32;
5454 pub type SCM_PD_MEDIA_REINITIALIZATION_STATUS = i32;
5455 pub const ScmPhysicalDeviceReinit_Success: SCM_PD_MEDIA_REINITIALIZATION_STATUS = 0i32;
5456 pub const ScmPhysicalDeviceReinit_RebootNeeded: SCM_PD_MEDIA_REINITIALIZATION_STATUS = 1i32;
5457 pub const ScmPhysicalDeviceReinit_ColdBootNeeded: SCM_PD_MEDIA_REINITIALIZATION_STATUS = 2i32;
5458 pub const ScmPhysicalDeviceReinit_Max: SCM_PD_MEDIA_REINITIALIZATION_STATUS = 3i32;
5459 pub type SCM_PD_OPERATIONAL_STATUS = i32;
5460 pub const ScmPhysicalDeviceOpStatus_Unknown: SCM_PD_OPERATIONAL_STATUS = 0i32;
5461 pub const ScmPhysicalDeviceOpStatus_Ok: SCM_PD_OPERATIONAL_STATUS = 1i32;
5462 pub const ScmPhysicalDeviceOpStatus_PredictingFailure: SCM_PD_OPERATIONAL_STATUS = 2i32;
5463 pub const ScmPhysicalDeviceOpStatus_InService: SCM_PD_OPERATIONAL_STATUS = 3i32;
5464 pub const ScmPhysicalDeviceOpStatus_HardwareError: SCM_PD_OPERATIONAL_STATUS = 4i32;
5465 pub const ScmPhysicalDeviceOpStatus_NotUsable: SCM_PD_OPERATIONAL_STATUS = 5i32;
5466 pub const ScmPhysicalDeviceOpStatus_TransientError: SCM_PD_OPERATIONAL_STATUS = 6i32;
5467 pub const ScmPhysicalDeviceOpStatus_Missing: SCM_PD_OPERATIONAL_STATUS = 7i32;
5468 pub const ScmPhysicalDeviceOpStatus_Max: SCM_PD_OPERATIONAL_STATUS = 8i32;
5469 pub type SCM_PD_OPERATIONAL_STATUS_REASON = i32;
5470 pub const ScmPhysicalDeviceOpReason_Unknown: SCM_PD_OPERATIONAL_STATUS_REASON = 0i32;
5471 pub const ScmPhysicalDeviceOpReason_Media: SCM_PD_OPERATIONAL_STATUS_REASON = 1i32;
5472 pub const ScmPhysicalDeviceOpReason_ThresholdExceeded: SCM_PD_OPERATIONAL_STATUS_REASON = 2i32;
5473 pub const ScmPhysicalDeviceOpReason_LostData: SCM_PD_OPERATIONAL_STATUS_REASON = 3i32;
5474 pub const ScmPhysicalDeviceOpReason_EnergySource: SCM_PD_OPERATIONAL_STATUS_REASON = 4i32;
5475 pub const ScmPhysicalDeviceOpReason_Configuration: SCM_PD_OPERATIONAL_STATUS_REASON = 5i32;
5476 pub const ScmPhysicalDeviceOpReason_DeviceController: SCM_PD_OPERATIONAL_STATUS_REASON = 6i32;
5477 pub const ScmPhysicalDeviceOpReason_MediaController: SCM_PD_OPERATIONAL_STATUS_REASON = 7i32;
5478 pub const ScmPhysicalDeviceOpReason_Component: SCM_PD_OPERATIONAL_STATUS_REASON = 8i32;
5479 pub const ScmPhysicalDeviceOpReason_BackgroundOperation: SCM_PD_OPERATIONAL_STATUS_REASON = 9i32;
5480 pub const ScmPhysicalDeviceOpReason_InvalidFirmware: SCM_PD_OPERATIONAL_STATUS_REASON = 10i32;
5481 pub const ScmPhysicalDeviceOpReason_HealthCheck: SCM_PD_OPERATIONAL_STATUS_REASON = 11i32;
5482 pub const ScmPhysicalDeviceOpReason_LostDataPersistence: SCM_PD_OPERATIONAL_STATUS_REASON = 12i32;
5483 pub const ScmPhysicalDeviceOpReason_DisabledByPlatform: SCM_PD_OPERATIONAL_STATUS_REASON = 13i32;
5484 pub const ScmPhysicalDeviceOpReason_PermanentError: SCM_PD_OPERATIONAL_STATUS_REASON = 14i32;
5485 pub const ScmPhysicalDeviceOpReason_LostWritePersistence: SCM_PD_OPERATIONAL_STATUS_REASON = 15i32;
5486 pub const ScmPhysicalDeviceOpReason_FatalError: SCM_PD_OPERATIONAL_STATUS_REASON = 16i32;
5487 pub const ScmPhysicalDeviceOpReason_DataPersistenceLossImminent: SCM_PD_OPERATIONAL_STATUS_REASON = 17i32;
5488 pub const ScmPhysicalDeviceOpReason_WritePersistenceLossImminent: SCM_PD_OPERATIONAL_STATUS_REASON = 18i32;
5489 pub const ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock: SCM_PD_OPERATIONAL_STATUS_REASON = 19i32;
5490 pub const ScmPhysicalDeviceOpReason_PerformanceDegradation: SCM_PD_OPERATIONAL_STATUS_REASON = 20i32;
5491 pub const ScmPhysicalDeviceOpReason_ExcessiveTemperature: SCM_PD_OPERATIONAL_STATUS_REASON = 21i32;
5492 pub const ScmPhysicalDeviceOpReason_InternalFailure: SCM_PD_OPERATIONAL_STATUS_REASON = 22i32;
5493 pub const ScmPhysicalDeviceOpReason_Max: SCM_PD_OPERATIONAL_STATUS_REASON = 23i32;
5494 #[repr(C)]
5495 pub struct SCM_PD_PASSTHROUGH_INPUT {
5496     pub Version: u32,
5497     pub Size: u32,
5498     pub ProtocolGuid: ::windows_sys::core::GUID,
5499     pub DataSize: u32,
5500     pub Data: [u8; 1],
5501 }
5502 impl ::core::marker::Copy for SCM_PD_PASSTHROUGH_INPUT {}
5503 impl ::core::clone::Clone for SCM_PD_PASSTHROUGH_INPUT {
5504     fn clone(&self) -> Self {
5505         *self
5506     }
5507 }
5508 #[repr(C)]
5509 pub struct SCM_PD_PASSTHROUGH_INVDIMM_INPUT {
5510     pub Opcode: u32,
5511     pub OpcodeParametersLength: u32,
5512     pub OpcodeParameters: [u8; 1],
5513 }
5514 impl ::core::marker::Copy for SCM_PD_PASSTHROUGH_INVDIMM_INPUT {}
5515 impl ::core::clone::Clone for SCM_PD_PASSTHROUGH_INVDIMM_INPUT {
5516     fn clone(&self) -> Self {
5517         *self
5518     }
5519 }
5520 #[repr(C)]
5521 pub struct SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT {
5522     pub GeneralStatus: u16,
5523     pub ExtendedStatus: u16,
5524     pub OutputDataLength: u32,
5525     pub OutputData: [u8; 1],
5526 }
5527 impl ::core::marker::Copy for SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT {}
5528 impl ::core::clone::Clone for SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT {
5529     fn clone(&self) -> Self {
5530         *self
5531     }
5532 }
5533 #[repr(C)]
5534 pub struct SCM_PD_PASSTHROUGH_OUTPUT {
5535     pub Version: u32,
5536     pub Size: u32,
5537     pub ProtocolGuid: ::windows_sys::core::GUID,
5538     pub DataSize: u32,
5539     pub Data: [u8; 1],
5540 }
5541 impl ::core::marker::Copy for SCM_PD_PASSTHROUGH_OUTPUT {}
5542 impl ::core::clone::Clone for SCM_PD_PASSTHROUGH_OUTPUT {
5543     fn clone(&self) -> Self {
5544         *self
5545     }
5546 }
5547 pub type SCM_PD_PROPERTY_ID = i32;
5548 pub const ScmPhysicalDeviceProperty_DeviceInfo: SCM_PD_PROPERTY_ID = 0i32;
5549 pub const ScmPhysicalDeviceProperty_ManagementStatus: SCM_PD_PROPERTY_ID = 1i32;
5550 pub const ScmPhysicalDeviceProperty_FirmwareInfo: SCM_PD_PROPERTY_ID = 2i32;
5551 pub const ScmPhysicalDeviceProperty_LocationString: SCM_PD_PROPERTY_ID = 3i32;
5552 pub const ScmPhysicalDeviceProperty_DeviceSpecificInfo: SCM_PD_PROPERTY_ID = 4i32;
5553 pub const ScmPhysicalDeviceProperty_DeviceHandle: SCM_PD_PROPERTY_ID = 5i32;
5554 pub const ScmPhysicalDeviceProperty_FruIdString: SCM_PD_PROPERTY_ID = 6i32;
5555 pub const ScmPhysicalDeviceProperty_RuntimeFwActivationInfo: SCM_PD_PROPERTY_ID = 7i32;
5556 pub const ScmPhysicalDeviceProperty_RuntimeFwActivationArmState: SCM_PD_PROPERTY_ID = 8i32;
5557 pub const ScmPhysicalDeviceProperty_Max: SCM_PD_PROPERTY_ID = 9i32;
5558 pub const SCM_PD_PROPERTY_NAME_LENGTH_IN_CHARS: u32 = 128u32;
5559 #[repr(C)]
5560 pub struct SCM_PD_PROPERTY_QUERY {
5561     pub Version: u32,
5562     pub Size: u32,
5563     pub PropertyId: SCM_PD_PROPERTY_ID,
5564     pub QueryType: SCM_PD_QUERY_TYPE,
5565     pub AdditionalParameters: [u8; 1],
5566 }
5567 impl ::core::marker::Copy for SCM_PD_PROPERTY_QUERY {}
5568 impl ::core::clone::Clone for SCM_PD_PROPERTY_QUERY {
5569     fn clone(&self) -> Self {
5570         *self
5571     }
5572 }
5573 #[repr(C)]
5574 pub struct SCM_PD_PROPERTY_SET {
5575     pub Version: u32,
5576     pub Size: u32,
5577     pub PropertyId: SCM_PD_PROPERTY_ID,
5578     pub SetType: SCM_PD_SET_TYPE,
5579     pub AdditionalParameters: [u8; 1],
5580 }
5581 impl ::core::marker::Copy for SCM_PD_PROPERTY_SET {}
5582 impl ::core::clone::Clone for SCM_PD_PROPERTY_SET {
5583     fn clone(&self) -> Self {
5584         *self
5585     }
5586 }
5587 pub type SCM_PD_QUERY_TYPE = i32;
5588 pub const ScmPhysicalDeviceQuery_Descriptor: SCM_PD_QUERY_TYPE = 0i32;
5589 pub const ScmPhysicalDeviceQuery_IsSupported: SCM_PD_QUERY_TYPE = 1i32;
5590 pub const ScmPhysicalDeviceQuery_Max: SCM_PD_QUERY_TYPE = 2i32;
5591 #[repr(C)]
5592 pub struct SCM_PD_REINITIALIZE_MEDIA_INPUT {
5593     pub Version: u32,
5594     pub Size: u32,
5595     pub Options: SCM_PD_REINITIALIZE_MEDIA_INPUT_0,
5596 }
5597 impl ::core::marker::Copy for SCM_PD_REINITIALIZE_MEDIA_INPUT {}
5598 impl ::core::clone::Clone for SCM_PD_REINITIALIZE_MEDIA_INPUT {
5599     fn clone(&self) -> Self {
5600         *self
5601     }
5602 }
5603 #[repr(C)]
5604 pub struct SCM_PD_REINITIALIZE_MEDIA_INPUT_0 {
5605     pub _bitfield: u32,
5606 }
5607 impl ::core::marker::Copy for SCM_PD_REINITIALIZE_MEDIA_INPUT_0 {}
5608 impl ::core::clone::Clone for SCM_PD_REINITIALIZE_MEDIA_INPUT_0 {
5609     fn clone(&self) -> Self {
5610         *self
5611     }
5612 }
5613 #[repr(C)]
5614 pub struct SCM_PD_REINITIALIZE_MEDIA_OUTPUT {
5615     pub Version: u32,
5616     pub Size: u32,
5617     pub Status: SCM_PD_MEDIA_REINITIALIZATION_STATUS,
5618 }
5619 impl ::core::marker::Copy for SCM_PD_REINITIALIZE_MEDIA_OUTPUT {}
5620 impl ::core::clone::Clone for SCM_PD_REINITIALIZE_MEDIA_OUTPUT {
5621     fn clone(&self) -> Self {
5622         *self
5623     }
5624 }
5625 #[repr(C)]
5626 #[cfg(feature = "Win32_Foundation")]
5627 pub struct SCM_PD_RUNTIME_FW_ACTIVATION_ARM_STATE {
5628     pub ArmState: super::super::Foundation::BOOLEAN,
5629 }
5630 #[cfg(feature = "Win32_Foundation")]
5631 impl ::core::marker::Copy for SCM_PD_RUNTIME_FW_ACTIVATION_ARM_STATE {}
5632 #[cfg(feature = "Win32_Foundation")]
5633 impl ::core::clone::Clone for SCM_PD_RUNTIME_FW_ACTIVATION_ARM_STATE {
5634     fn clone(&self) -> Self {
5635         *self
5636     }
5637 }
5638 #[repr(C)]
5639 pub struct SCM_PD_RUNTIME_FW_ACTIVATION_INFO {
5640     pub Version: u32,
5641     pub Size: u32,
5642     pub LastFirmwareActivationStatus: SCM_PD_LAST_FW_ACTIVATION_STATUS,
5643     pub FirmwareActivationState: SCM_PD_FIRMWARE_ACTIVATION_STATE,
5644 }
5645 impl ::core::marker::Copy for SCM_PD_RUNTIME_FW_ACTIVATION_INFO {}
5646 impl ::core::clone::Clone for SCM_PD_RUNTIME_FW_ACTIVATION_INFO {
5647     fn clone(&self) -> Self {
5648         *self
5649     }
5650 }
5651 pub type SCM_PD_SET_TYPE = i32;
5652 pub const ScmPhysicalDeviceSet_Descriptor: SCM_PD_SET_TYPE = 0i32;
5653 pub const ScmPhysicalDeviceSet_IsSupported: SCM_PD_SET_TYPE = 1i32;
5654 pub const ScmPhysicalDeviceSet_Max: SCM_PD_SET_TYPE = 2i32;
5655 #[repr(C)]
5656 pub struct SCM_PHYSICAL_DEVICES {
5657     pub Version: u32,
5658     pub Size: u32,
5659     pub DeviceCount: u32,
5660     pub Devices: [SCM_PHYSICAL_DEVICE_INSTANCE; 1],
5661 }
5662 impl ::core::marker::Copy for SCM_PHYSICAL_DEVICES {}
5663 impl ::core::clone::Clone for SCM_PHYSICAL_DEVICES {
5664     fn clone(&self) -> Self {
5665         *self
5666     }
5667 }
5668 #[repr(C)]
5669 pub struct SCM_PHYSICAL_DEVICE_INSTANCE {
5670     pub Version: u32,
5671     pub Size: u32,
5672     pub NfitHandle: u32,
5673     pub SymbolicLink: [u16; 256],
5674 }
5675 impl ::core::marker::Copy for SCM_PHYSICAL_DEVICE_INSTANCE {}
5676 impl ::core::clone::Clone for SCM_PHYSICAL_DEVICE_INSTANCE {
5677     fn clone(&self) -> Self {
5678         *self
5679     }
5680 }
5681 #[repr(C)]
5682 pub struct SCM_REGION {
5683     pub Version: u32,
5684     pub Size: u32,
5685     pub Flags: u32,
5686     pub NfitHandle: u32,
5687     pub LogicalDeviceGuid: ::windows_sys::core::GUID,
5688     pub AddressRangeType: ::windows_sys::core::GUID,
5689     pub AssociatedId: u32,
5690     pub Length: u64,
5691     pub StartingDPA: u64,
5692     pub BaseSPA: u64,
5693     pub SPAOffset: u64,
5694     pub RegionOffset: u64,
5695 }
5696 impl ::core::marker::Copy for SCM_REGION {}
5697 impl ::core::clone::Clone for SCM_REGION {
5698     fn clone(&self) -> Self {
5699         *self
5700     }
5701 }
5702 #[repr(C)]
5703 pub struct SCM_REGIONS {
5704     pub Version: u32,
5705     pub Size: u32,
5706     pub RegionCount: u32,
5707     pub Regions: [SCM_REGION; 1],
5708 }
5709 impl ::core::marker::Copy for SCM_REGIONS {}
5710 impl ::core::clone::Clone for SCM_REGIONS {
5711     fn clone(&self) -> Self {
5712         *self
5713     }
5714 }
5715 pub type SCM_REGION_FLAG = i32;
5716 pub const ScmRegionFlagNone: SCM_REGION_FLAG = 0i32;
5717 pub const ScmRegionFlagLabel: SCM_REGION_FLAG = 1i32;
5718 #[repr(C)]
5719 pub struct SD_CHANGE_MACHINE_SID_INPUT {
5720     pub CurrentMachineSIDOffset: u16,
5721     pub CurrentMachineSIDLength: u16,
5722     pub NewMachineSIDOffset: u16,
5723     pub NewMachineSIDLength: u16,
5724 }
5725 impl ::core::marker::Copy for SD_CHANGE_MACHINE_SID_INPUT {}
5726 impl ::core::clone::Clone for SD_CHANGE_MACHINE_SID_INPUT {
5727     fn clone(&self) -> Self {
5728         *self
5729     }
5730 }
5731 #[repr(C)]
5732 pub struct SD_CHANGE_MACHINE_SID_OUTPUT {
5733     pub NumSDChangedSuccess: u64,
5734     pub NumSDChangedFail: u64,
5735     pub NumSDUnused: u64,
5736     pub NumSDTotal: u64,
5737     pub NumMftSDChangedSuccess: u64,
5738     pub NumMftSDChangedFail: u64,
5739     pub NumMftSDTotal: u64,
5740 }
5741 impl ::core::marker::Copy for SD_CHANGE_MACHINE_SID_OUTPUT {}
5742 impl ::core::clone::Clone for SD_CHANGE_MACHINE_SID_OUTPUT {
5743     fn clone(&self) -> Self {
5744         *self
5745     }
5746 }
5747 #[repr(C)]
5748 pub struct SD_ENUM_SDS_ENTRY {
5749     pub Hash: u32,
5750     pub SecurityId: u32,
5751     pub Offset: u64,
5752     pub Length: u32,
5753     pub Descriptor: [u8; 1],
5754 }
5755 impl ::core::marker::Copy for SD_ENUM_SDS_ENTRY {}
5756 impl ::core::clone::Clone for SD_ENUM_SDS_ENTRY {
5757     fn clone(&self) -> Self {
5758         *self
5759     }
5760 }
5761 #[repr(C)]
5762 pub struct SD_ENUM_SDS_INPUT {
5763     pub StartingOffset: u64,
5764     pub MaxSDEntriesToReturn: u64,
5765 }
5766 impl ::core::marker::Copy for SD_ENUM_SDS_INPUT {}
5767 impl ::core::clone::Clone for SD_ENUM_SDS_INPUT {
5768     fn clone(&self) -> Self {
5769         *self
5770     }
5771 }
5772 #[repr(C)]
5773 pub struct SD_ENUM_SDS_OUTPUT {
5774     pub NextOffset: u64,
5775     pub NumSDEntriesReturned: u64,
5776     pub NumSDBytesReturned: u64,
5777     pub SDEntry: [SD_ENUM_SDS_ENTRY; 1],
5778 }
5779 impl ::core::marker::Copy for SD_ENUM_SDS_OUTPUT {}
5780 impl ::core::clone::Clone for SD_ENUM_SDS_OUTPUT {
5781     fn clone(&self) -> Self {
5782         *self
5783     }
5784 }
5785 #[repr(C)]
5786 pub struct SD_GLOBAL_CHANGE_INPUT {
5787     pub Flags: u32,
5788     pub ChangeType: u32,
5789     pub Anonymous: SD_GLOBAL_CHANGE_INPUT_0,
5790 }
5791 impl ::core::marker::Copy for SD_GLOBAL_CHANGE_INPUT {}
5792 impl ::core::clone::Clone for SD_GLOBAL_CHANGE_INPUT {
5793     fn clone(&self) -> Self {
5794         *self
5795     }
5796 }
5797 #[repr(C)]
5798 pub union SD_GLOBAL_CHANGE_INPUT_0 {
5799     pub SdChange: SD_CHANGE_MACHINE_SID_INPUT,
5800     pub SdQueryStats: SD_QUERY_STATS_INPUT,
5801     pub SdEnumSds: SD_ENUM_SDS_INPUT,
5802 }
5803 impl ::core::marker::Copy for SD_GLOBAL_CHANGE_INPUT_0 {}
5804 impl ::core::clone::Clone for SD_GLOBAL_CHANGE_INPUT_0 {
5805     fn clone(&self) -> Self {
5806         *self
5807     }
5808 }
5809 #[repr(C)]
5810 pub struct SD_GLOBAL_CHANGE_OUTPUT {
5811     pub Flags: u32,
5812     pub ChangeType: u32,
5813     pub Anonymous: SD_GLOBAL_CHANGE_OUTPUT_0,
5814 }
5815 impl ::core::marker::Copy for SD_GLOBAL_CHANGE_OUTPUT {}
5816 impl ::core::clone::Clone for SD_GLOBAL_CHANGE_OUTPUT {
5817     fn clone(&self) -> Self {
5818         *self
5819     }
5820 }
5821 #[repr(C)]
5822 pub union SD_GLOBAL_CHANGE_OUTPUT_0 {
5823     pub SdChange: SD_CHANGE_MACHINE_SID_OUTPUT,
5824     pub SdQueryStats: SD_QUERY_STATS_OUTPUT,
5825     pub SdEnumSds: SD_ENUM_SDS_OUTPUT,
5826 }
5827 impl ::core::marker::Copy for SD_GLOBAL_CHANGE_OUTPUT_0 {}
5828 impl ::core::clone::Clone for SD_GLOBAL_CHANGE_OUTPUT_0 {
5829     fn clone(&self) -> Self {
5830         *self
5831     }
5832 }
5833 pub const SD_GLOBAL_CHANGE_TYPE_ENUM_SDS: u32 = 131072u32;
5834 pub const SD_GLOBAL_CHANGE_TYPE_MACHINE_SID: u32 = 1u32;
5835 pub const SD_GLOBAL_CHANGE_TYPE_QUERY_STATS: u32 = 65536u32;
5836 #[repr(C)]
5837 pub struct SD_QUERY_STATS_INPUT {
5838     pub Reserved: u32,
5839 }
5840 impl ::core::marker::Copy for SD_QUERY_STATS_INPUT {}
5841 impl ::core::clone::Clone for SD_QUERY_STATS_INPUT {
5842     fn clone(&self) -> Self {
5843         *self
5844     }
5845 }
5846 #[repr(C)]
5847 pub struct SD_QUERY_STATS_OUTPUT {
5848     pub SdsStreamSize: u64,
5849     pub SdsAllocationSize: u64,
5850     pub SiiStreamSize: u64,
5851     pub SiiAllocationSize: u64,
5852     pub SdhStreamSize: u64,
5853     pub SdhAllocationSize: u64,
5854     pub NumSDTotal: u64,
5855     pub NumSDUnused: u64,
5856 }
5857 impl ::core::marker::Copy for SD_QUERY_STATS_OUTPUT {}
5858 impl ::core::clone::Clone for SD_QUERY_STATS_OUTPUT {
5859     fn clone(&self) -> Self {
5860         *self
5861     }
5862 }
5863 pub const SEARCH_ALL: u32 = 0u32;
5864 pub const SEARCH_ALL_NO_SEQ: u32 = 4u32;
5865 pub const SEARCH_ALTERNATE: u32 = 2u32;
5866 pub const SEARCH_ALT_NO_SEQ: u32 = 6u32;
5867 pub const SEARCH_PRIMARY: u32 = 1u32;
5868 pub const SEARCH_PRI_NO_SEQ: u32 = 5u32;
5869 #[repr(C, packed(1))]
5870 pub struct SENDCMDINPARAMS {
5871     pub cBufferSize: u32,
5872     pub irDriveRegs: IDEREGS,
5873     pub bDriveNumber: u8,
5874     pub bReserved: [u8; 3],
5875     pub dwReserved: [u32; 4],
5876     pub bBuffer: [u8; 1],
5877 }
5878 impl ::core::marker::Copy for SENDCMDINPARAMS {}
5879 impl ::core::clone::Clone for SENDCMDINPARAMS {
5880     fn clone(&self) -> Self {
5881         *self
5882     }
5883 }
5884 #[repr(C, packed(1))]
5885 pub struct SENDCMDOUTPARAMS {
5886     pub cBufferSize: u32,
5887     pub DriverStatus: DRIVERSTATUS,
5888     pub bBuffer: [u8; 1],
5889 }
5890 impl ::core::marker::Copy for SENDCMDOUTPARAMS {}
5891 impl ::core::clone::Clone for SENDCMDOUTPARAMS {
5892     fn clone(&self) -> Self {
5893         *self
5894     }
5895 }
5896 pub const SERIAL_NUMBER_LENGTH: u32 = 32u32;
5897 #[repr(C)]
5898 pub struct SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT {
5899     pub Flags: u32,
5900     pub AlignmentShift: u32,
5901     pub FileOffsetToAlign: u64,
5902     pub FallbackAlignmentShift: u32,
5903 }
5904 impl ::core::marker::Copy for SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT {}
5905 impl ::core::clone::Clone for SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT {
5906     fn clone(&self) -> Self {
5907         *self
5908     }
5909 }
5910 #[repr(C)]
5911 #[cfg(feature = "Win32_Foundation")]
5912 pub struct SET_DISK_ATTRIBUTES {
5913     pub Version: u32,
5914     pub Persist: super::super::Foundation::BOOLEAN,
5915     pub Reserved1: [u8; 3],
5916     pub Attributes: u64,
5917     pub AttributesMask: u64,
5918     pub Reserved2: [u32; 4],
5919 }
5920 #[cfg(feature = "Win32_Foundation")]
5921 impl ::core::marker::Copy for SET_DISK_ATTRIBUTES {}
5922 #[cfg(feature = "Win32_Foundation")]
5923 impl ::core::clone::Clone for SET_DISK_ATTRIBUTES {
5924     fn clone(&self) -> Self {
5925         *self
5926     }
5927 }
5928 #[repr(C)]
5929 pub struct SET_PARTITION_INFORMATION {
5930     pub PartitionType: u8,
5931 }
5932 impl ::core::marker::Copy for SET_PARTITION_INFORMATION {}
5933 impl ::core::clone::Clone for SET_PARTITION_INFORMATION {
5934     fn clone(&self) -> Self {
5935         *self
5936     }
5937 }
5938 #[repr(C)]
5939 pub struct SET_PARTITION_INFORMATION_EX {
5940     pub PartitionStyle: PARTITION_STYLE,
5941     pub Anonymous: SET_PARTITION_INFORMATION_EX_0,
5942 }
5943 impl ::core::marker::Copy for SET_PARTITION_INFORMATION_EX {}
5944 impl ::core::clone::Clone for SET_PARTITION_INFORMATION_EX {
5945     fn clone(&self) -> Self {
5946         *self
5947     }
5948 }
5949 #[repr(C)]
5950 pub union SET_PARTITION_INFORMATION_EX_0 {
5951     pub Mbr: SET_PARTITION_INFORMATION,
5952     pub Gpt: PARTITION_INFORMATION_GPT,
5953 }
5954 impl ::core::marker::Copy for SET_PARTITION_INFORMATION_EX_0 {}
5955 impl ::core::clone::Clone for SET_PARTITION_INFORMATION_EX_0 {
5956     fn clone(&self) -> Self {
5957         *self
5958     }
5959 }
5960 pub const SET_PURGE_FAILURE_MODE_DISABLED: u32 = 2u32;
5961 pub const SET_PURGE_FAILURE_MODE_ENABLED: u32 = 1u32;
5962 #[repr(C)]
5963 pub struct SET_PURGE_FAILURE_MODE_INPUT {
5964     pub Flags: u32,
5965 }
5966 impl ::core::marker::Copy for SET_PURGE_FAILURE_MODE_INPUT {}
5967 impl ::core::clone::Clone for SET_PURGE_FAILURE_MODE_INPUT {
5968     fn clone(&self) -> Self {
5969         *self
5970     }
5971 }
5972 pub const SET_REPAIR_DISABLED_AND_BUGCHECK_ON_CORRUPT: u32 = 16u32;
5973 pub const SET_REPAIR_ENABLED: u32 = 1u32;
5974 pub const SET_REPAIR_VALID_MASK: u32 = 25u32;
5975 pub const SET_REPAIR_WARN_ABOUT_DATA_LOSS: u32 = 8u32;
5976 #[repr(C)]
5977 pub struct SHRINK_VOLUME_INFORMATION {
5978     pub ShrinkRequestType: SHRINK_VOLUME_REQUEST_TYPES,
5979     pub Flags: u64,
5980     pub NewNumberOfSectors: i64,
5981 }
5982 impl ::core::marker::Copy for SHRINK_VOLUME_INFORMATION {}
5983 impl ::core::clone::Clone for SHRINK_VOLUME_INFORMATION {
5984     fn clone(&self) -> Self {
5985         *self
5986     }
5987 }
5988 pub type SHRINK_VOLUME_REQUEST_TYPES = i32;
5989 pub const ShrinkPrepare: SHRINK_VOLUME_REQUEST_TYPES = 1i32;
5990 pub const ShrinkCommit: SHRINK_VOLUME_REQUEST_TYPES = 2i32;
5991 pub const ShrinkAbort: SHRINK_VOLUME_REQUEST_TYPES = 3i32;
5992 #[repr(C)]
5993 pub struct SI_COPYFILE {
5994     pub SourceFileNameLength: u32,
5995     pub DestinationFileNameLength: u32,
5996     pub Flags: u32,
5997     pub FileNameBuffer: [u16; 1],
5998 }
5999 impl ::core::marker::Copy for SI_COPYFILE {}
6000 impl ::core::clone::Clone for SI_COPYFILE {
6001     fn clone(&self) -> Self {
6002         *self
6003     }
6004 }
6005 pub const SMART_ABORT_OFFLINE_SELFTEST: u32 = 127u32;
6006 pub const SMART_CMD: u32 = 176u32;
6007 pub const SMART_CYL_HI: u32 = 194u32;
6008 pub const SMART_CYL_LOW: u32 = 79u32;
6009 pub const SMART_ERROR_NO_MEM: u32 = 7u32;
6010 pub const SMART_EXTENDED_SELFTEST_CAPTIVE: u32 = 130u32;
6011 pub const SMART_EXTENDED_SELFTEST_OFFLINE: u32 = 2u32;
6012 pub const SMART_GET_VERSION: u32 = 475264u32;
6013 pub const SMART_IDE_ERROR: u32 = 1u32;
6014 pub const SMART_INVALID_BUFFER: u32 = 4u32;
6015 pub const SMART_INVALID_COMMAND: u32 = 3u32;
6016 pub const SMART_INVALID_DRIVE: u32 = 5u32;
6017 pub const SMART_INVALID_FLAG: u32 = 2u32;
6018 pub const SMART_INVALID_IOCTL: u32 = 6u32;
6019 pub const SMART_INVALID_REGISTER: u32 = 8u32;
6020 pub const SMART_LOG_SECTOR_SIZE: u32 = 512u32;
6021 pub const SMART_NOT_SUPPORTED: u32 = 9u32;
6022 pub const SMART_NO_ERROR: u32 = 0u32;
6023 pub const SMART_NO_IDE_DEVICE: u32 = 10u32;
6024 pub const SMART_OFFLINE_ROUTINE_OFFLINE: u32 = 0u32;
6025 pub const SMART_RCV_DRIVE_DATA: u32 = 508040u32;
6026 pub const SMART_RCV_DRIVE_DATA_EX: u32 = 458892u32;
6027 pub const SMART_READ_LOG: u32 = 213u32;
6028 pub const SMART_SEND_DRIVE_COMMAND: u32 = 508036u32;
6029 pub const SMART_SHORT_SELFTEST_CAPTIVE: u32 = 129u32;
6030 pub const SMART_SHORT_SELFTEST_OFFLINE: u32 = 1u32;
6031 pub const SMART_WRITE_LOG: u32 = 214u32;
6032 #[repr(C)]
6033 pub struct SMB_SHARE_FLUSH_AND_PURGE_INPUT {
6034     pub Version: u16,
6035 }
6036 impl ::core::marker::Copy for SMB_SHARE_FLUSH_AND_PURGE_INPUT {}
6037 impl ::core::clone::Clone for SMB_SHARE_FLUSH_AND_PURGE_INPUT {
6038     fn clone(&self) -> Self {
6039         *self
6040     }
6041 }
6042 #[repr(C)]
6043 pub struct SMB_SHARE_FLUSH_AND_PURGE_OUTPUT {
6044     pub cEntriesPurged: u32,
6045 }
6046 impl ::core::marker::Copy for SMB_SHARE_FLUSH_AND_PURGE_OUTPUT {}
6047 impl ::core::clone::Clone for SMB_SHARE_FLUSH_AND_PURGE_OUTPUT {
6048     fn clone(&self) -> Self {
6049         *self
6050     }
6051 }
6052 pub const SPACES_TRACKED_OFFSET_HEADER_FLAG: u32 = 2u32;
6053 pub const SRB_TYPE_SCSI_REQUEST_BLOCK: u32 = 0u32;
6054 pub const SRB_TYPE_STORAGE_REQUEST_BLOCK: u32 = 1u32;
6055 #[repr(C)]
6056 pub struct STARTING_LCN_INPUT_BUFFER {
6057     pub StartingLcn: i64,
6058 }
6059 impl ::core::marker::Copy for STARTING_LCN_INPUT_BUFFER {}
6060 impl ::core::clone::Clone for STARTING_LCN_INPUT_BUFFER {
6061     fn clone(&self) -> Self {
6062         *self
6063     }
6064 }
6065 #[repr(C)]
6066 pub struct STARTING_LCN_INPUT_BUFFER_EX {
6067     pub StartingLcn: i64,
6068     pub Flags: u32,
6069 }
6070 impl ::core::marker::Copy for STARTING_LCN_INPUT_BUFFER_EX {}
6071 impl ::core::clone::Clone for STARTING_LCN_INPUT_BUFFER_EX {
6072     fn clone(&self) -> Self {
6073         *self
6074     }
6075 }
6076 #[repr(C)]
6077 pub struct STARTING_VCN_INPUT_BUFFER {
6078     pub StartingVcn: i64,
6079 }
6080 impl ::core::marker::Copy for STARTING_VCN_INPUT_BUFFER {}
6081 impl ::core::clone::Clone for STARTING_VCN_INPUT_BUFFER {
6082     fn clone(&self) -> Self {
6083         *self
6084     }
6085 }
6086 #[repr(C)]
6087 pub struct STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR {
6088     pub Version: u32,
6089     pub Size: u32,
6090     pub BytesPerCacheLine: u32,
6091     pub BytesOffsetForCacheAlignment: u32,
6092     pub BytesPerLogicalSector: u32,
6093     pub BytesPerPhysicalSector: u32,
6094     pub BytesOffsetForSectorAlignment: u32,
6095 }
6096 impl ::core::marker::Copy for STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR {}
6097 impl ::core::clone::Clone for STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR {
6098     fn clone(&self) -> Self {
6099         *self
6100     }
6101 }
6102 #[repr(C)]
6103 #[cfg(feature = "Win32_Foundation")]
6104 pub struct STORAGE_ADAPTER_DESCRIPTOR {
6105     pub Version: u32,
6106     pub Size: u32,
6107     pub MaximumTransferLength: u32,
6108     pub MaximumPhysicalPages: u32,
6109     pub AlignmentMask: u32,
6110     pub AdapterUsesPio: super::super::Foundation::BOOLEAN,
6111     pub AdapterScansDown: super::super::Foundation::BOOLEAN,
6112     pub CommandQueueing: super::super::Foundation::BOOLEAN,
6113     pub AcceleratedTransfer: super::super::Foundation::BOOLEAN,
6114     pub BusType: u8,
6115     pub BusMajorVersion: u16,
6116     pub BusMinorVersion: u16,
6117     pub SrbType: u8,
6118     pub AddressType: u8,
6119 }
6120 #[cfg(feature = "Win32_Foundation")]
6121 impl ::core::marker::Copy for STORAGE_ADAPTER_DESCRIPTOR {}
6122 #[cfg(feature = "Win32_Foundation")]
6123 impl ::core::clone::Clone for STORAGE_ADAPTER_DESCRIPTOR {
6124     fn clone(&self) -> Self {
6125         *self
6126     }
6127 }
6128 #[repr(C)]
6129 pub struct STORAGE_ADAPTER_SERIAL_NUMBER {
6130     pub Version: u32,
6131     pub Size: u32,
6132     pub SerialNumber: [u16; 128],
6133 }
6134 impl ::core::marker::Copy for STORAGE_ADAPTER_SERIAL_NUMBER {}
6135 impl ::core::clone::Clone for STORAGE_ADAPTER_SERIAL_NUMBER {
6136     fn clone(&self) -> Self {
6137         *self
6138     }
6139 }
6140 pub const STORAGE_ADAPTER_SERIAL_NUMBER_V1_MAX_LENGTH: u32 = 128u32;
6141 pub const STORAGE_ADDRESS_TYPE_BTL8: u32 = 0u32;
6142 #[repr(C)]
6143 #[cfg(feature = "Win32_Foundation")]
6144 pub struct STORAGE_ALLOCATE_BC_STREAM_INPUT {
6145     pub Version: u32,
6146     pub RequestsPerPeriod: u32,
6147     pub Period: u32,
6148     pub RetryFailures: super::super::Foundation::BOOLEAN,
6149     pub Discardable: super::super::Foundation::BOOLEAN,
6150     pub Reserved1: [super::super::Foundation::BOOLEAN; 2],
6151     pub AccessType: u32,
6152     pub AccessMode: u32,
6153 }
6154 #[cfg(feature = "Win32_Foundation")]
6155 impl ::core::marker::Copy for STORAGE_ALLOCATE_BC_STREAM_INPUT {}
6156 #[cfg(feature = "Win32_Foundation")]
6157 impl ::core::clone::Clone for STORAGE_ALLOCATE_BC_STREAM_INPUT {
6158     fn clone(&self) -> Self {
6159         *self
6160     }
6161 }
6162 #[repr(C)]
6163 pub struct STORAGE_ALLOCATE_BC_STREAM_OUTPUT {
6164     pub RequestSize: u64,
6165     pub NumOutStandingRequests: u32,
6166 }
6167 impl ::core::marker::Copy for STORAGE_ALLOCATE_BC_STREAM_OUTPUT {}
6168 impl ::core::clone::Clone for STORAGE_ALLOCATE_BC_STREAM_OUTPUT {
6169     fn clone(&self) -> Self {
6170         *self
6171     }
6172 }
6173 pub type STORAGE_ASSOCIATION_TYPE = i32;
6174 pub const StorageIdAssocDevice: STORAGE_ASSOCIATION_TYPE = 0i32;
6175 pub const StorageIdAssocPort: STORAGE_ASSOCIATION_TYPE = 1i32;
6176 pub const StorageIdAssocTarget: STORAGE_ASSOCIATION_TYPE = 2i32;
6177 pub const STORAGE_ATTRIBUTE_ASYNC_EVENT_NOTIFICATION: u32 = 16u32;
6178 pub const STORAGE_ATTRIBUTE_BLOCK_IO: u32 = 2u32;
6179 pub const STORAGE_ATTRIBUTE_BYTE_ADDRESSABLE_IO: u32 = 1u32;
6180 pub const STORAGE_ATTRIBUTE_DYNAMIC_PERSISTENCE: u32 = 4u32;
6181 #[repr(C)]
6182 pub struct STORAGE_ATTRIBUTE_MGMT {
6183     pub Version: u32,
6184     pub Size: u32,
6185     pub Action: STORAGE_ATTRIBUTE_MGMT_ACTION,
6186     pub Attribute: u32,
6187 }
6188 impl ::core::marker::Copy for STORAGE_ATTRIBUTE_MGMT {}
6189 impl ::core::clone::Clone for STORAGE_ATTRIBUTE_MGMT {
6190     fn clone(&self) -> Self {
6191         *self
6192     }
6193 }
6194 pub type STORAGE_ATTRIBUTE_MGMT_ACTION = i32;
6195 pub const StorAttributeMgmt_ClearAttribute: STORAGE_ATTRIBUTE_MGMT_ACTION = 0i32;
6196 pub const StorAttributeMgmt_SetAttribute: STORAGE_ATTRIBUTE_MGMT_ACTION = 1i32;
6197 pub const StorAttributeMgmt_ResetAttribute: STORAGE_ATTRIBUTE_MGMT_ACTION = 2i32;
6198 pub const STORAGE_ATTRIBUTE_PERF_SIZE_INDEPENDENT: u32 = 32u32;
6199 pub const STORAGE_ATTRIBUTE_VOLATILE: u32 = 8u32;
6200 #[repr(C)]
6201 pub struct STORAGE_BREAK_RESERVATION_REQUEST {
6202     pub Length: u32,
6203     pub _unused: u8,
6204     pub PathId: u8,
6205     pub TargetId: u8,
6206     pub Lun: u8,
6207 }
6208 impl ::core::marker::Copy for STORAGE_BREAK_RESERVATION_REQUEST {}
6209 impl ::core::clone::Clone for STORAGE_BREAK_RESERVATION_REQUEST {
6210     fn clone(&self) -> Self {
6211         *self
6212     }
6213 }
6214 #[repr(C)]
6215 pub struct STORAGE_BUS_RESET_REQUEST {
6216     pub PathId: u8,
6217 }
6218 impl ::core::marker::Copy for STORAGE_BUS_RESET_REQUEST {}
6219 impl ::core::clone::Clone for STORAGE_BUS_RESET_REQUEST {
6220     fn clone(&self) -> Self {
6221         *self
6222     }
6223 }
6224 pub type STORAGE_COMPONENT_HEALTH_STATUS = i32;
6225 pub const HealthStatusUnknown: STORAGE_COMPONENT_HEALTH_STATUS = 0i32;
6226 pub const HealthStatusNormal: STORAGE_COMPONENT_HEALTH_STATUS = 1i32;
6227 pub const HealthStatusThrottled: STORAGE_COMPONENT_HEALTH_STATUS = 2i32;
6228 pub const HealthStatusWarning: STORAGE_COMPONENT_HEALTH_STATUS = 3i32;
6229 pub const HealthStatusDisabled: STORAGE_COMPONENT_HEALTH_STATUS = 4i32;
6230 pub const HealthStatusFailed: STORAGE_COMPONENT_HEALTH_STATUS = 5i32;
6231 pub const STORAGE_COMPONENT_ROLE_CACHE: u32 = 1u32;
6232 pub const STORAGE_COMPONENT_ROLE_DATA: u32 = 4u32;
6233 pub const STORAGE_COMPONENT_ROLE_TIERING: u32 = 2u32;
6234 #[repr(C)]
6235 pub struct STORAGE_COUNTER {
6236     pub Type: STORAGE_COUNTER_TYPE,
6237     pub Value: STORAGE_COUNTER_0,
6238 }
6239 impl ::core::marker::Copy for STORAGE_COUNTER {}
6240 impl ::core::clone::Clone for STORAGE_COUNTER {
6241     fn clone(&self) -> Self {
6242         *self
6243     }
6244 }
6245 #[repr(C)]
6246 pub union STORAGE_COUNTER_0 {
6247     pub ManufactureDate: STORAGE_COUNTER_0_0,
6248     pub AsUlonglong: u64,
6249 }
6250 impl ::core::marker::Copy for STORAGE_COUNTER_0 {}
6251 impl ::core::clone::Clone for STORAGE_COUNTER_0 {
6252     fn clone(&self) -> Self {
6253         *self
6254     }
6255 }
6256 #[repr(C)]
6257 pub struct STORAGE_COUNTER_0_0 {
6258     pub Week: u32,
6259     pub Year: u32,
6260 }
6261 impl ::core::marker::Copy for STORAGE_COUNTER_0_0 {}
6262 impl ::core::clone::Clone for STORAGE_COUNTER_0_0 {
6263     fn clone(&self) -> Self {
6264         *self
6265     }
6266 }
6267 #[repr(C)]
6268 pub struct STORAGE_COUNTERS {
6269     pub Version: u32,
6270     pub Size: u32,
6271     pub NumberOfCounters: u32,
6272     pub Counters: [STORAGE_COUNTER; 1],
6273 }
6274 impl ::core::marker::Copy for STORAGE_COUNTERS {}
6275 impl ::core::clone::Clone for STORAGE_COUNTERS {
6276     fn clone(&self) -> Self {
6277         *self
6278     }
6279 }
6280 pub type STORAGE_COUNTER_TYPE = i32;
6281 pub const StorageCounterTypeUnknown: STORAGE_COUNTER_TYPE = 0i32;
6282 pub const StorageCounterTypeTemperatureCelsius: STORAGE_COUNTER_TYPE = 1i32;
6283 pub const StorageCounterTypeTemperatureCelsiusMax: STORAGE_COUNTER_TYPE = 2i32;
6284 pub const StorageCounterTypeReadErrorsTotal: STORAGE_COUNTER_TYPE = 3i32;
6285 pub const StorageCounterTypeReadErrorsCorrected: STORAGE_COUNTER_TYPE = 4i32;
6286 pub const StorageCounterTypeReadErrorsUncorrected: STORAGE_COUNTER_TYPE = 5i32;
6287 pub const StorageCounterTypeWriteErrorsTotal: STORAGE_COUNTER_TYPE = 6i32;
6288 pub const StorageCounterTypeWriteErrorsCorrected: STORAGE_COUNTER_TYPE = 7i32;
6289 pub const StorageCounterTypeWriteErrorsUncorrected: STORAGE_COUNTER_TYPE = 8i32;
6290 pub const StorageCounterTypeManufactureDate: STORAGE_COUNTER_TYPE = 9i32;
6291 pub const StorageCounterTypeStartStopCycleCount: STORAGE_COUNTER_TYPE = 10i32;
6292 pub const StorageCounterTypeStartStopCycleCountMax: STORAGE_COUNTER_TYPE = 11i32;
6293 pub const StorageCounterTypeLoadUnloadCycleCount: STORAGE_COUNTER_TYPE = 12i32;
6294 pub const StorageCounterTypeLoadUnloadCycleCountMax: STORAGE_COUNTER_TYPE = 13i32;
6295 pub const StorageCounterTypeWearPercentage: STORAGE_COUNTER_TYPE = 14i32;
6296 pub const StorageCounterTypeWearPercentageWarning: STORAGE_COUNTER_TYPE = 15i32;
6297 pub const StorageCounterTypeWearPercentageMax: STORAGE_COUNTER_TYPE = 16i32;
6298 pub const StorageCounterTypePowerOnHours: STORAGE_COUNTER_TYPE = 17i32;
6299 pub const StorageCounterTypeReadLatency100NSMax: STORAGE_COUNTER_TYPE = 18i32;
6300 pub const StorageCounterTypeWriteLatency100NSMax: STORAGE_COUNTER_TYPE = 19i32;
6301 pub const StorageCounterTypeFlushLatency100NSMax: STORAGE_COUNTER_TYPE = 20i32;
6302 pub const StorageCounterTypeMax: STORAGE_COUNTER_TYPE = 21i32;
6303 pub type STORAGE_CRYPTO_ALGORITHM_ID = i32;
6304 pub const StorageCryptoAlgorithmUnknown: STORAGE_CRYPTO_ALGORITHM_ID = 0i32;
6305 pub const StorageCryptoAlgorithmXTSAES: STORAGE_CRYPTO_ALGORITHM_ID = 1i32;
6306 pub const StorageCryptoAlgorithmBitlockerAESCBC: STORAGE_CRYPTO_ALGORITHM_ID = 2i32;
6307 pub const StorageCryptoAlgorithmAESECB: STORAGE_CRYPTO_ALGORITHM_ID = 3i32;
6308 pub const StorageCryptoAlgorithmESSIVAESCBC: STORAGE_CRYPTO_ALGORITHM_ID = 4i32;
6309 pub const StorageCryptoAlgorithmMax: STORAGE_CRYPTO_ALGORITHM_ID = 5i32;
6310 #[repr(C)]
6311 pub struct STORAGE_CRYPTO_CAPABILITY {
6312     pub Version: u32,
6313     pub Size: u32,
6314     pub CryptoCapabilityIndex: u32,
6315     pub AlgorithmId: STORAGE_CRYPTO_ALGORITHM_ID,
6316     pub KeySize: STORAGE_CRYPTO_KEY_SIZE,
6317     pub DataUnitSizeBitmask: u32,
6318 }
6319 impl ::core::marker::Copy for STORAGE_CRYPTO_CAPABILITY {}
6320 impl ::core::clone::Clone for STORAGE_CRYPTO_CAPABILITY {
6321     fn clone(&self) -> Self {
6322         *self
6323     }
6324 }
6325 pub const STORAGE_CRYPTO_CAPABILITY_VERSION_1: u32 = 1u32;
6326 #[repr(C)]
6327 pub struct STORAGE_CRYPTO_DESCRIPTOR {
6328     pub Version: u32,
6329     pub Size: u32,
6330     pub NumKeysSupported: u32,
6331     pub NumCryptoCapabilities: u32,
6332     pub CryptoCapabilities: [STORAGE_CRYPTO_CAPABILITY; 1],
6333 }
6334 impl ::core::marker::Copy for STORAGE_CRYPTO_DESCRIPTOR {}
6335 impl ::core::clone::Clone for STORAGE_CRYPTO_DESCRIPTOR {
6336     fn clone(&self) -> Self {
6337         *self
6338     }
6339 }
6340 pub const STORAGE_CRYPTO_DESCRIPTOR_VERSION_1: u32 = 1u32;
6341 pub type STORAGE_CRYPTO_KEY_SIZE = i32;
6342 pub const StorageCryptoKeySizeUnknown: STORAGE_CRYPTO_KEY_SIZE = 0i32;
6343 pub const StorageCryptoKeySize128Bits: STORAGE_CRYPTO_KEY_SIZE = 1i32;
6344 pub const StorageCryptoKeySize192Bits: STORAGE_CRYPTO_KEY_SIZE = 2i32;
6345 pub const StorageCryptoKeySize256Bits: STORAGE_CRYPTO_KEY_SIZE = 3i32;
6346 pub const StorageCryptoKeySize512Bits: STORAGE_CRYPTO_KEY_SIZE = 4i32;
6347 #[repr(C)]
6348 pub struct STORAGE_DESCRIPTOR_HEADER {
6349     pub Version: u32,
6350     pub Size: u32,
6351 }
6352 impl ::core::marker::Copy for STORAGE_DESCRIPTOR_HEADER {}
6353 impl ::core::clone::Clone for STORAGE_DESCRIPTOR_HEADER {
6354     fn clone(&self) -> Self {
6355         *self
6356     }
6357 }
6358 #[repr(C)]
6359 pub struct STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR {
6360     pub Version: u32,
6361     pub Size: u32,
6362     pub Attributes: u64,
6363 }
6364 impl ::core::marker::Copy for STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR {}
6365 impl ::core::clone::Clone for STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR {
6366     fn clone(&self) -> Self {
6367         *self
6368     }
6369 }
6370 #[repr(C)]
6371 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
6372 pub struct STORAGE_DEVICE_DESCRIPTOR {
6373     pub Version: u32,
6374     pub Size: u32,
6375     pub DeviceType: u8,
6376     pub DeviceTypeModifier: u8,
6377     pub RemovableMedia: super::super::Foundation::BOOLEAN,
6378     pub CommandQueueing: super::super::Foundation::BOOLEAN,
6379     pub VendorIdOffset: u32,
6380     pub ProductIdOffset: u32,
6381     pub ProductRevisionOffset: u32,
6382     pub SerialNumberOffset: u32,
6383     pub BusType: super::super::Storage::FileSystem::STORAGE_BUS_TYPE,
6384     pub RawPropertiesLength: u32,
6385     pub RawDeviceProperties: [u8; 1],
6386 }
6387 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
6388 impl ::core::marker::Copy for STORAGE_DEVICE_DESCRIPTOR {}
6389 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
6390 impl ::core::clone::Clone for STORAGE_DEVICE_DESCRIPTOR {
6391     fn clone(&self) -> Self {
6392         *self
6393     }
6394 }
6395 #[repr(C)]
6396 pub struct STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR {
6397     pub Version: u32,
6398     pub Size: u32,
6399     pub NumberOfFaultDomains: u32,
6400     pub FaultDomainIds: [::windows_sys::core::GUID; 1],
6401 }
6402 impl ::core::marker::Copy for STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR {}
6403 impl ::core::clone::Clone for STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR {
6404     fn clone(&self) -> Self {
6405         *self
6406     }
6407 }
6408 pub const STORAGE_DEVICE_FLAGS_PAGE_83_DEVICEGUID: u32 = 4u32;
6409 pub const STORAGE_DEVICE_FLAGS_RANDOM_DEVICEGUID_REASON_CONFLICT: u32 = 1u32;
6410 pub const STORAGE_DEVICE_FLAGS_RANDOM_DEVICEGUID_REASON_NOHWID: u32 = 2u32;
6411 pub type STORAGE_DEVICE_FORM_FACTOR = i32;
6412 pub const FormFactorUnknown: STORAGE_DEVICE_FORM_FACTOR = 0i32;
6413 pub const FormFactor3_5: STORAGE_DEVICE_FORM_FACTOR = 1i32;
6414 pub const FormFactor2_5: STORAGE_DEVICE_FORM_FACTOR = 2i32;
6415 pub const FormFactor1_8: STORAGE_DEVICE_FORM_FACTOR = 3i32;
6416 pub const FormFactor1_8Less: STORAGE_DEVICE_FORM_FACTOR = 4i32;
6417 pub const FormFactorEmbedded: STORAGE_DEVICE_FORM_FACTOR = 5i32;
6418 pub const FormFactorMemoryCard: STORAGE_DEVICE_FORM_FACTOR = 6i32;
6419 pub const FormFactormSata: STORAGE_DEVICE_FORM_FACTOR = 7i32;
6420 pub const FormFactorM_2: STORAGE_DEVICE_FORM_FACTOR = 8i32;
6421 pub const FormFactorPCIeBoard: STORAGE_DEVICE_FORM_FACTOR = 9i32;
6422 pub const FormFactorDimm: STORAGE_DEVICE_FORM_FACTOR = 10i32;
6423 #[repr(C)]
6424 pub struct STORAGE_DEVICE_ID_DESCRIPTOR {
6425     pub Version: u32,
6426     pub Size: u32,
6427     pub NumberOfIdentifiers: u32,
6428     pub Identifiers: [u8; 1],
6429 }
6430 impl ::core::marker::Copy for STORAGE_DEVICE_ID_DESCRIPTOR {}
6431 impl ::core::clone::Clone for STORAGE_DEVICE_ID_DESCRIPTOR {
6432     fn clone(&self) -> Self {
6433         *self
6434     }
6435 }
6436 #[repr(C)]
6437 pub struct STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR {
6438     pub Version: u32,
6439     pub Size: u32,
6440     pub LunMaxIoCount: u32,
6441     pub AdapterMaxIoCount: u32,
6442 }
6443 impl ::core::marker::Copy for STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR {}
6444 impl ::core::clone::Clone for STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR {
6445     fn clone(&self) -> Self {
6446         *self
6447     }
6448 }
6449 #[repr(C)]
6450 pub struct STORAGE_DEVICE_LED_STATE_DESCRIPTOR {
6451     pub Version: u32,
6452     pub Size: u32,
6453     pub State: u64,
6454 }
6455 impl ::core::marker::Copy for STORAGE_DEVICE_LED_STATE_DESCRIPTOR {}
6456 impl ::core::clone::Clone for STORAGE_DEVICE_LED_STATE_DESCRIPTOR {
6457     fn clone(&self) -> Self {
6458         *self
6459     }
6460 }
6461 #[repr(C)]
6462 pub struct STORAGE_DEVICE_LOCATION_DESCRIPTOR {
6463     pub Version: u32,
6464     pub Size: u32,
6465     pub Location: DEVICE_LOCATION,
6466     pub StringOffset: u32,
6467 }
6468 impl ::core::marker::Copy for STORAGE_DEVICE_LOCATION_DESCRIPTOR {}
6469 impl ::core::clone::Clone for STORAGE_DEVICE_LOCATION_DESCRIPTOR {
6470     fn clone(&self) -> Self {
6471         *self
6472     }
6473 }
6474 #[repr(C)]
6475 pub struct STORAGE_DEVICE_MANAGEMENT_STATUS {
6476     pub Version: u32,
6477     pub Size: u32,
6478     pub Health: STORAGE_DISK_HEALTH_STATUS,
6479     pub NumberOfOperationalStatus: u32,
6480     pub NumberOfAdditionalReasons: u32,
6481     pub OperationalStatus: [STORAGE_DISK_OPERATIONAL_STATUS; 16],
6482     pub AdditionalReasons: [STORAGE_OPERATIONAL_REASON; 1],
6483 }
6484 impl ::core::marker::Copy for STORAGE_DEVICE_MANAGEMENT_STATUS {}
6485 impl ::core::clone::Clone for STORAGE_DEVICE_MANAGEMENT_STATUS {
6486     fn clone(&self) -> Self {
6487         *self
6488     }
6489 }
6490 pub const STORAGE_DEVICE_MAX_OPERATIONAL_STATUS: u32 = 16u32;
6491 pub const STORAGE_DEVICE_NUMA_NODE_UNKNOWN: u32 = 4294967295u32;
6492 #[repr(C)]
6493 pub struct STORAGE_DEVICE_NUMA_PROPERTY {
6494     pub Version: u32,
6495     pub Size: u32,
6496     pub NumaNode: u32,
6497 }
6498 impl ::core::marker::Copy for STORAGE_DEVICE_NUMA_PROPERTY {}
6499 impl ::core::clone::Clone for STORAGE_DEVICE_NUMA_PROPERTY {
6500     fn clone(&self) -> Self {
6501         *self
6502     }
6503 }
6504 #[repr(C)]
6505 pub struct STORAGE_DEVICE_NUMBER {
6506     pub DeviceType: u32,
6507     pub DeviceNumber: u32,
6508     pub PartitionNumber: u32,
6509 }
6510 impl ::core::marker::Copy for STORAGE_DEVICE_NUMBER {}
6511 impl ::core::clone::Clone for STORAGE_DEVICE_NUMBER {
6512     fn clone(&self) -> Self {
6513         *self
6514     }
6515 }
6516 #[repr(C)]
6517 pub struct STORAGE_DEVICE_NUMBERS {
6518     pub Version: u32,
6519     pub Size: u32,
6520     pub NumberOfDevices: u32,
6521     pub Devices: [STORAGE_DEVICE_NUMBER; 1],
6522 }
6523 impl ::core::marker::Copy for STORAGE_DEVICE_NUMBERS {}
6524 impl ::core::clone::Clone for STORAGE_DEVICE_NUMBERS {
6525     fn clone(&self) -> Self {
6526         *self
6527     }
6528 }
6529 #[repr(C)]
6530 pub struct STORAGE_DEVICE_NUMBER_EX {
6531     pub Version: u32,
6532     pub Size: u32,
6533     pub Flags: u32,
6534     pub DeviceType: u32,
6535     pub DeviceNumber: u32,
6536     pub DeviceGuid: ::windows_sys::core::GUID,
6537     pub PartitionNumber: u32,
6538 }
6539 impl ::core::marker::Copy for STORAGE_DEVICE_NUMBER_EX {}
6540 impl ::core::clone::Clone for STORAGE_DEVICE_NUMBER_EX {
6541     fn clone(&self) -> Self {
6542         *self
6543     }
6544 }
6545 #[repr(C)]
6546 pub struct STORAGE_DEVICE_POWER_CAP {
6547     pub Version: u32,
6548     pub Size: u32,
6549     pub Units: STORAGE_DEVICE_POWER_CAP_UNITS,
6550     pub MaxPower: u64,
6551 }
6552 impl ::core::marker::Copy for STORAGE_DEVICE_POWER_CAP {}
6553 impl ::core::clone::Clone for STORAGE_DEVICE_POWER_CAP {
6554     fn clone(&self) -> Self {
6555         *self
6556     }
6557 }
6558 pub type STORAGE_DEVICE_POWER_CAP_UNITS = i32;
6559 pub const StorageDevicePowerCapUnitsPercent: STORAGE_DEVICE_POWER_CAP_UNITS = 0i32;
6560 pub const StorageDevicePowerCapUnitsMilliwatts: STORAGE_DEVICE_POWER_CAP_UNITS = 1i32;
6561 pub const STORAGE_DEVICE_POWER_CAP_VERSION_V1: u32 = 1u32;
6562 #[repr(C)]
6563 pub struct STORAGE_DEVICE_RESILIENCY_DESCRIPTOR {
6564     pub Version: u32,
6565     pub Size: u32,
6566     pub NameOffset: u32,
6567     pub NumberOfLogicalCopies: u32,
6568     pub NumberOfPhysicalCopies: u32,
6569     pub PhysicalDiskRedundancy: u32,
6570     pub NumberOfColumns: u32,
6571     pub Interleave: u32,
6572 }
6573 impl ::core::marker::Copy for STORAGE_DEVICE_RESILIENCY_DESCRIPTOR {}
6574 impl ::core::clone::Clone for STORAGE_DEVICE_RESILIENCY_DESCRIPTOR {
6575     fn clone(&self) -> Self {
6576         *self
6577     }
6578 }
6579 #[repr(C)]
6580 #[cfg(feature = "Win32_Foundation")]
6581 pub struct STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY {
6582     pub Version: u32,
6583     pub Size: u32,
6584     pub SupportsSelfEncryption: super::super::Foundation::BOOLEAN,
6585 }
6586 #[cfg(feature = "Win32_Foundation")]
6587 impl ::core::marker::Copy for STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY {}
6588 #[cfg(feature = "Win32_Foundation")]
6589 impl ::core::clone::Clone for STORAGE_DEVICE_SELF_ENCRYPTION_PROPERTY {
6590     fn clone(&self) -> Self {
6591         *self
6592     }
6593 }
6594 #[repr(C)]
6595 pub struct STORAGE_DEVICE_TIERING_DESCRIPTOR {
6596     pub Version: u32,
6597     pub Size: u32,
6598     pub Flags: u32,
6599     pub TotalNumberOfTiers: u32,
6600     pub NumberOfTiersReturned: u32,
6601     pub Tiers: [STORAGE_TIER; 1],
6602 }
6603 impl ::core::marker::Copy for STORAGE_DEVICE_TIERING_DESCRIPTOR {}
6604 impl ::core::clone::Clone for STORAGE_DEVICE_TIERING_DESCRIPTOR {
6605     fn clone(&self) -> Self {
6606         *self
6607     }
6608 }
6609 #[repr(C)]
6610 pub struct STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT {
6611     pub Version: u32,
6612     pub Size: u32,
6613     pub UnsafeShutdownCount: u32,
6614 }
6615 impl ::core::marker::Copy for STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT {}
6616 impl ::core::clone::Clone for STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT {
6617     fn clone(&self) -> Self {
6618         *self
6619     }
6620 }
6621 #[repr(C)]
6622 pub struct STORAGE_DIAGNOSTIC_DATA {
6623     pub Version: u32,
6624     pub Size: u32,
6625     pub ProviderId: ::windows_sys::core::GUID,
6626     pub BufferSize: u32,
6627     pub Reserved: u32,
6628     pub DiagnosticDataBuffer: [u8; 1],
6629 }
6630 impl ::core::marker::Copy for STORAGE_DIAGNOSTIC_DATA {}
6631 impl ::core::clone::Clone for STORAGE_DIAGNOSTIC_DATA {
6632     fn clone(&self) -> Self {
6633         *self
6634     }
6635 }
6636 pub const STORAGE_DIAGNOSTIC_FLAG_ADAPTER_REQUEST: u32 = 1u32;
6637 pub type STORAGE_DIAGNOSTIC_LEVEL = i32;
6638 pub const StorageDiagnosticLevelDefault: STORAGE_DIAGNOSTIC_LEVEL = 0i32;
6639 pub const StorageDiagnosticLevelMax: STORAGE_DIAGNOSTIC_LEVEL = 1i32;
6640 #[repr(C)]
6641 pub struct STORAGE_DIAGNOSTIC_REQUEST {
6642     pub Version: u32,
6643     pub Size: u32,
6644     pub Flags: u32,
6645     pub TargetType: STORAGE_DIAGNOSTIC_TARGET_TYPE,
6646     pub Level: STORAGE_DIAGNOSTIC_LEVEL,
6647 }
6648 impl ::core::marker::Copy for STORAGE_DIAGNOSTIC_REQUEST {}
6649 impl ::core::clone::Clone for STORAGE_DIAGNOSTIC_REQUEST {
6650     fn clone(&self) -> Self {
6651         *self
6652     }
6653 }
6654 pub type STORAGE_DIAGNOSTIC_TARGET_TYPE = i32;
6655 pub const StorageDiagnosticTargetTypeUndefined: STORAGE_DIAGNOSTIC_TARGET_TYPE = 0i32;
6656 pub const StorageDiagnosticTargetTypePort: STORAGE_DIAGNOSTIC_TARGET_TYPE = 1i32;
6657 pub const StorageDiagnosticTargetTypeMiniport: STORAGE_DIAGNOSTIC_TARGET_TYPE = 2i32;
6658 pub const StorageDiagnosticTargetTypeHbaFirmware: STORAGE_DIAGNOSTIC_TARGET_TYPE = 3i32;
6659 pub const StorageDiagnosticTargetTypeMax: STORAGE_DIAGNOSTIC_TARGET_TYPE = 4i32;
6660 pub type STORAGE_DISK_HEALTH_STATUS = i32;
6661 pub const DiskHealthUnknown: STORAGE_DISK_HEALTH_STATUS = 0i32;
6662 pub const DiskHealthUnhealthy: STORAGE_DISK_HEALTH_STATUS = 1i32;
6663 pub const DiskHealthWarning: STORAGE_DISK_HEALTH_STATUS = 2i32;
6664 pub const DiskHealthHealthy: STORAGE_DISK_HEALTH_STATUS = 3i32;
6665 pub const DiskHealthMax: STORAGE_DISK_HEALTH_STATUS = 4i32;
6666 pub type STORAGE_DISK_OPERATIONAL_STATUS = i32;
6667 pub const DiskOpStatusNone: STORAGE_DISK_OPERATIONAL_STATUS = 0i32;
6668 pub const DiskOpStatusUnknown: STORAGE_DISK_OPERATIONAL_STATUS = 1i32;
6669 pub const DiskOpStatusOk: STORAGE_DISK_OPERATIONAL_STATUS = 2i32;
6670 pub const DiskOpStatusPredictingFailure: STORAGE_DISK_OPERATIONAL_STATUS = 3i32;
6671 pub const DiskOpStatusInService: STORAGE_DISK_OPERATIONAL_STATUS = 4i32;
6672 pub const DiskOpStatusHardwareError: STORAGE_DISK_OPERATIONAL_STATUS = 5i32;
6673 pub const DiskOpStatusNotUsable: STORAGE_DISK_OPERATIONAL_STATUS = 6i32;
6674 pub const DiskOpStatusTransientError: STORAGE_DISK_OPERATIONAL_STATUS = 7i32;
6675 pub const DiskOpStatusMissing: STORAGE_DISK_OPERATIONAL_STATUS = 8i32;
6676 pub const STORAGE_EVENT_DEVICE_OPERATION: u64 = 4u64;
6677 pub const STORAGE_EVENT_DEVICE_STATUS: u64 = 2u64;
6678 pub const STORAGE_EVENT_MEDIA_STATUS: u64 = 1u64;
6679 #[repr(C)]
6680 pub struct STORAGE_EVENT_NOTIFICATION {
6681     pub Version: u32,
6682     pub Size: u32,
6683     pub Events: u64,
6684 }
6685 impl ::core::marker::Copy for STORAGE_EVENT_NOTIFICATION {}
6686 impl ::core::clone::Clone for STORAGE_EVENT_NOTIFICATION {
6687     fn clone(&self) -> Self {
6688         *self
6689     }
6690 }
6691 pub const STORAGE_EVENT_NOTIFICATION_VERSION_V1: u32 = 1u32;
6692 #[repr(C)]
6693 #[cfg(feature = "Win32_Foundation")]
6694 pub struct STORAGE_FAILURE_PREDICTION_CONFIG {
6695     pub Version: u32,
6696     pub Size: u32,
6697     pub Set: super::super::Foundation::BOOLEAN,
6698     pub Enabled: super::super::Foundation::BOOLEAN,
6699     pub Reserved: u16,
6700 }
6701 #[cfg(feature = "Win32_Foundation")]
6702 impl ::core::marker::Copy for STORAGE_FAILURE_PREDICTION_CONFIG {}
6703 #[cfg(feature = "Win32_Foundation")]
6704 impl ::core::clone::Clone for STORAGE_FAILURE_PREDICTION_CONFIG {
6705     fn clone(&self) -> Self {
6706         *self
6707     }
6708 }
6709 pub const STORAGE_FAILURE_PREDICTION_CONFIG_V1: u32 = 1u32;
6710 #[repr(C)]
6711 pub struct STORAGE_FRU_ID_DESCRIPTOR {
6712     pub Version: u32,
6713     pub Size: u32,
6714     pub IdentifierSize: u32,
6715     pub Identifier: [u8; 1],
6716 }
6717 impl ::core::marker::Copy for STORAGE_FRU_ID_DESCRIPTOR {}
6718 impl ::core::clone::Clone for STORAGE_FRU_ID_DESCRIPTOR {
6719     fn clone(&self) -> Self {
6720         *self
6721     }
6722 }
6723 #[repr(C)]
6724 pub struct STORAGE_GET_BC_PROPERTIES_OUTPUT {
6725     pub MaximumRequestsPerPeriod: u32,
6726     pub MinimumPeriod: u32,
6727     pub MaximumRequestSize: u64,
6728     pub EstimatedTimePerRequest: u32,
6729     pub NumOutStandingRequests: u32,
6730     pub RequestSize: u64,
6731 }
6732 impl ::core::marker::Copy for STORAGE_GET_BC_PROPERTIES_OUTPUT {}
6733 impl ::core::clone::Clone for STORAGE_GET_BC_PROPERTIES_OUTPUT {
6734     fn clone(&self) -> Self {
6735         *self
6736     }
6737 }
6738 #[repr(C)]
6739 #[cfg(feature = "Win32_Foundation")]
6740 pub struct STORAGE_HOTPLUG_INFO {
6741     pub Size: u32,
6742     pub MediaRemovable: super::super::Foundation::BOOLEAN,
6743     pub MediaHotplug: super::super::Foundation::BOOLEAN,
6744     pub DeviceHotplug: super::super::Foundation::BOOLEAN,
6745     pub WriteCacheEnableOverride: super::super::Foundation::BOOLEAN,
6746 }
6747 #[cfg(feature = "Win32_Foundation")]
6748 impl ::core::marker::Copy for STORAGE_HOTPLUG_INFO {}
6749 #[cfg(feature = "Win32_Foundation")]
6750 impl ::core::clone::Clone for STORAGE_HOTPLUG_INFO {
6751     fn clone(&self) -> Self {
6752         *self
6753     }
6754 }
6755 #[repr(C)]
6756 pub struct STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR {
6757     pub Version: u32,
6758     pub Size: u32,
6759     pub EnduranceInfo: STORAGE_HW_ENDURANCE_INFO,
6760 }
6761 impl ::core::marker::Copy for STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR {}
6762 impl ::core::clone::Clone for STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR {
6763     fn clone(&self) -> Self {
6764         *self
6765     }
6766 }
6767 #[repr(C)]
6768 pub struct STORAGE_HW_ENDURANCE_INFO {
6769     pub ValidFields: u32,
6770     pub GroupId: u32,
6771     pub Flags: STORAGE_HW_ENDURANCE_INFO_0,
6772     pub LifePercentage: u32,
6773     pub BytesReadCount: [u8; 16],
6774     pub ByteWriteCount: [u8; 16],
6775 }
6776 impl ::core::marker::Copy for STORAGE_HW_ENDURANCE_INFO {}
6777 impl ::core::clone::Clone for STORAGE_HW_ENDURANCE_INFO {
6778     fn clone(&self) -> Self {
6779         *self
6780     }
6781 }
6782 #[repr(C)]
6783 pub struct STORAGE_HW_ENDURANCE_INFO_0 {
6784     pub _bitfield: u32,
6785 }
6786 impl ::core::marker::Copy for STORAGE_HW_ENDURANCE_INFO_0 {}
6787 impl ::core::clone::Clone for STORAGE_HW_ENDURANCE_INFO_0 {
6788     fn clone(&self) -> Self {
6789         *self
6790     }
6791 }
6792 #[repr(C)]
6793 pub struct STORAGE_HW_FIRMWARE_ACTIVATE {
6794     pub Version: u32,
6795     pub Size: u32,
6796     pub Flags: u32,
6797     pub Slot: u8,
6798     pub Reserved0: [u8; 3],
6799 }
6800 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_ACTIVATE {}
6801 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_ACTIVATE {
6802     fn clone(&self) -> Self {
6803         *self
6804     }
6805 }
6806 #[repr(C)]
6807 pub struct STORAGE_HW_FIRMWARE_DOWNLOAD {
6808     pub Version: u32,
6809     pub Size: u32,
6810     pub Flags: u32,
6811     pub Slot: u8,
6812     pub Reserved: [u8; 3],
6813     pub Offset: u64,
6814     pub BufferSize: u64,
6815     pub ImageBuffer: [u8; 1],
6816 }
6817 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_DOWNLOAD {}
6818 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_DOWNLOAD {
6819     fn clone(&self) -> Self {
6820         *self
6821     }
6822 }
6823 #[repr(C)]
6824 pub struct STORAGE_HW_FIRMWARE_DOWNLOAD_V2 {
6825     pub Version: u32,
6826     pub Size: u32,
6827     pub Flags: u32,
6828     pub Slot: u8,
6829     pub Reserved: [u8; 3],
6830     pub Offset: u64,
6831     pub BufferSize: u64,
6832     pub ImageSize: u32,
6833     pub Reserved2: u32,
6834     pub ImageBuffer: [u8; 1],
6835 }
6836 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_DOWNLOAD_V2 {}
6837 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_DOWNLOAD_V2 {
6838     fn clone(&self) -> Self {
6839         *self
6840     }
6841 }
6842 #[repr(C)]
6843 #[cfg(feature = "Win32_Foundation")]
6844 pub struct STORAGE_HW_FIRMWARE_INFO {
6845     pub Version: u32,
6846     pub Size: u32,
6847     pub _bitfield: u8,
6848     pub SlotCount: u8,
6849     pub ActiveSlot: u8,
6850     pub PendingActivateSlot: u8,
6851     pub FirmwareShared: super::super::Foundation::BOOLEAN,
6852     pub Reserved: [u8; 3],
6853     pub ImagePayloadAlignment: u32,
6854     pub ImagePayloadMaxSize: u32,
6855     pub Slot: [STORAGE_HW_FIRMWARE_SLOT_INFO; 1],
6856 }
6857 #[cfg(feature = "Win32_Foundation")]
6858 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_INFO {}
6859 #[cfg(feature = "Win32_Foundation")]
6860 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_INFO {
6861     fn clone(&self) -> Self {
6862         *self
6863     }
6864 }
6865 #[repr(C)]
6866 pub struct STORAGE_HW_FIRMWARE_INFO_QUERY {
6867     pub Version: u32,
6868     pub Size: u32,
6869     pub Flags: u32,
6870     pub Reserved: u32,
6871 }
6872 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_INFO_QUERY {}
6873 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_INFO_QUERY {
6874     fn clone(&self) -> Self {
6875         *self
6876     }
6877 }
6878 pub const STORAGE_HW_FIRMWARE_INVALID_SLOT: u32 = 255u32;
6879 pub const STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER: u32 = 1u32;
6880 pub const STORAGE_HW_FIRMWARE_REQUEST_FLAG_FIRST_SEGMENT: u32 = 4u32;
6881 pub const STORAGE_HW_FIRMWARE_REQUEST_FLAG_LAST_SEGMENT: u32 = 2u32;
6882 pub const STORAGE_HW_FIRMWARE_REQUEST_FLAG_SWITCH_TO_EXISTING_FIRMWARE: u32 = 2147483648u32;
6883 pub const STORAGE_HW_FIRMWARE_REVISION_LENGTH: u32 = 16u32;
6884 #[repr(C)]
6885 pub struct STORAGE_HW_FIRMWARE_SLOT_INFO {
6886     pub Version: u32,
6887     pub Size: u32,
6888     pub SlotNumber: u8,
6889     pub _bitfield: u8,
6890     pub Reserved1: [u8; 6],
6891     pub Revision: [u8; 16],
6892 }
6893 impl ::core::marker::Copy for STORAGE_HW_FIRMWARE_SLOT_INFO {}
6894 impl ::core::clone::Clone for STORAGE_HW_FIRMWARE_SLOT_INFO {
6895     fn clone(&self) -> Self {
6896         *self
6897     }
6898 }
6899 #[repr(C)]
6900 pub struct STORAGE_IDENTIFIER {
6901     pub CodeSet: STORAGE_IDENTIFIER_CODE_SET,
6902     pub Type: STORAGE_IDENTIFIER_TYPE,
6903     pub IdentifierSize: u16,
6904     pub NextOffset: u16,
6905     pub Association: STORAGE_ASSOCIATION_TYPE,
6906     pub Identifier: [u8; 1],
6907 }
6908 impl ::core::marker::Copy for STORAGE_IDENTIFIER {}
6909 impl ::core::clone::Clone for STORAGE_IDENTIFIER {
6910     fn clone(&self) -> Self {
6911         *self
6912     }
6913 }
6914 pub type STORAGE_IDENTIFIER_CODE_SET = i32;
6915 pub const StorageIdCodeSetReserved: STORAGE_IDENTIFIER_CODE_SET = 0i32;
6916 pub const StorageIdCodeSetBinary: STORAGE_IDENTIFIER_CODE_SET = 1i32;
6917 pub const StorageIdCodeSetAscii: STORAGE_IDENTIFIER_CODE_SET = 2i32;
6918 pub const StorageIdCodeSetUtf8: STORAGE_IDENTIFIER_CODE_SET = 3i32;
6919 pub type STORAGE_IDENTIFIER_TYPE = i32;
6920 pub const StorageIdTypeVendorSpecific: STORAGE_IDENTIFIER_TYPE = 0i32;
6921 pub const StorageIdTypeVendorId: STORAGE_IDENTIFIER_TYPE = 1i32;
6922 pub const StorageIdTypeEUI64: STORAGE_IDENTIFIER_TYPE = 2i32;
6923 pub const StorageIdTypeFCPHName: STORAGE_IDENTIFIER_TYPE = 3i32;
6924 pub const StorageIdTypePortRelative: STORAGE_IDENTIFIER_TYPE = 4i32;
6925 pub const StorageIdTypeTargetPortGroup: STORAGE_IDENTIFIER_TYPE = 5i32;
6926 pub const StorageIdTypeLogicalUnitGroup: STORAGE_IDENTIFIER_TYPE = 6i32;
6927 pub const StorageIdTypeMD5LogicalUnitIdentifier: STORAGE_IDENTIFIER_TYPE = 7i32;
6928 pub const StorageIdTypeScsiNameString: STORAGE_IDENTIFIER_TYPE = 8i32;
6929 #[repr(C)]
6930 pub struct STORAGE_IDLE_POWER {
6931     pub Version: u32,
6932     pub Size: u32,
6933     pub _bitfield: u32,
6934     pub D3IdleTimeout: u32,
6935 }
6936 impl ::core::marker::Copy for STORAGE_IDLE_POWER {}
6937 impl ::core::clone::Clone for STORAGE_IDLE_POWER {
6938     fn clone(&self) -> Self {
6939         *self
6940     }
6941 }
6942 #[repr(C)]
6943 pub struct STORAGE_IDLE_POWERUP_REASON {
6944     pub Version: u32,
6945     pub Size: u32,
6946     pub PowerupReason: STORAGE_POWERUP_REASON_TYPE,
6947 }
6948 impl ::core::marker::Copy for STORAGE_IDLE_POWERUP_REASON {}
6949 impl ::core::clone::Clone for STORAGE_IDLE_POWERUP_REASON {
6950     fn clone(&self) -> Self {
6951         *self
6952     }
6953 }
6954 pub const STORAGE_IDLE_POWERUP_REASON_VERSION_V1: u32 = 1u32;
6955 pub type STORAGE_ID_NAA_FORMAT = i32;
6956 pub const StorageIdNAAFormatIEEEExtended: STORAGE_ID_NAA_FORMAT = 2i32;
6957 pub const StorageIdNAAFormatIEEERegistered: STORAGE_ID_NAA_FORMAT = 3i32;
6958 pub const StorageIdNAAFormatIEEEERegisteredExtended: STORAGE_ID_NAA_FORMAT = 5i32;
6959 #[repr(C)]
6960 pub struct STORAGE_LB_PROVISIONING_MAP_RESOURCES {
6961     pub Size: u32,
6962     pub Version: u32,
6963     pub _bitfield1: u8,
6964     pub Reserved1: [u8; 3],
6965     pub _bitfield2: u8,
6966     pub Reserved3: [u8; 3],
6967     pub AvailableMappingResources: u64,
6968     pub UsedMappingResources: u64,
6969 }
6970 impl ::core::marker::Copy for STORAGE_LB_PROVISIONING_MAP_RESOURCES {}
6971 impl ::core::clone::Clone for STORAGE_LB_PROVISIONING_MAP_RESOURCES {
6972     fn clone(&self) -> Self {
6973         *self
6974     }
6975 }
6976 #[repr(C)]
6977 pub struct STORAGE_MEDIA_SERIAL_NUMBER_DATA {
6978     pub Reserved: u16,
6979     pub SerialNumberLength: u16,
6980     pub SerialNumber: [u8; 1],
6981 }
6982 impl ::core::marker::Copy for STORAGE_MEDIA_SERIAL_NUMBER_DATA {}
6983 impl ::core::clone::Clone for STORAGE_MEDIA_SERIAL_NUMBER_DATA {
6984     fn clone(&self) -> Self {
6985         *self
6986     }
6987 }
6988 pub type STORAGE_MEDIA_TYPE = i32;
6989 pub const DDS_4mm: STORAGE_MEDIA_TYPE = 32i32;
6990 pub const MiniQic: STORAGE_MEDIA_TYPE = 33i32;
6991 pub const Travan: STORAGE_MEDIA_TYPE = 34i32;
6992 pub const QIC: STORAGE_MEDIA_TYPE = 35i32;
6993 pub const MP_8mm: STORAGE_MEDIA_TYPE = 36i32;
6994 pub const AME_8mm: STORAGE_MEDIA_TYPE = 37i32;
6995 pub const AIT1_8mm: STORAGE_MEDIA_TYPE = 38i32;
6996 pub const DLT: STORAGE_MEDIA_TYPE = 39i32;
6997 pub const NCTP: STORAGE_MEDIA_TYPE = 40i32;
6998 pub const IBM_3480: STORAGE_MEDIA_TYPE = 41i32;
6999 pub const IBM_3490E: STORAGE_MEDIA_TYPE = 42i32;
7000 pub const IBM_Magstar_3590: STORAGE_MEDIA_TYPE = 43i32;
7001 pub const IBM_Magstar_MP: STORAGE_MEDIA_TYPE = 44i32;
7002 pub const STK_DATA_D3: STORAGE_MEDIA_TYPE = 45i32;
7003 pub const SONY_DTF: STORAGE_MEDIA_TYPE = 46i32;
7004 pub const DV_6mm: STORAGE_MEDIA_TYPE = 47i32;
7005 pub const DMI: STORAGE_MEDIA_TYPE = 48i32;
7006 pub const SONY_D2: STORAGE_MEDIA_TYPE = 49i32;
7007 pub const CLEANER_CARTRIDGE: STORAGE_MEDIA_TYPE = 50i32;
7008 pub const CD_ROM: STORAGE_MEDIA_TYPE = 51i32;
7009 pub const CD_R: STORAGE_MEDIA_TYPE = 52i32;
7010 pub const CD_RW: STORAGE_MEDIA_TYPE = 53i32;
7011 pub const DVD_ROM: STORAGE_MEDIA_TYPE = 54i32;
7012 pub const DVD_R: STORAGE_MEDIA_TYPE = 55i32;
7013 pub const DVD_RW: STORAGE_MEDIA_TYPE = 56i32;
7014 pub const MO_3_RW: STORAGE_MEDIA_TYPE = 57i32;
7015 pub const MO_5_WO: STORAGE_MEDIA_TYPE = 58i32;
7016 pub const MO_5_RW: STORAGE_MEDIA_TYPE = 59i32;
7017 pub const MO_5_LIMDOW: STORAGE_MEDIA_TYPE = 60i32;
7018 pub const PC_5_WO: STORAGE_MEDIA_TYPE = 61i32;
7019 pub const PC_5_RW: STORAGE_MEDIA_TYPE = 62i32;
7020 pub const PD_5_RW: STORAGE_MEDIA_TYPE = 63i32;
7021 pub const ABL_5_WO: STORAGE_MEDIA_TYPE = 64i32;
7022 pub const PINNACLE_APEX_5_RW: STORAGE_MEDIA_TYPE = 65i32;
7023 pub const SONY_12_WO: STORAGE_MEDIA_TYPE = 66i32;
7024 pub const PHILIPS_12_WO: STORAGE_MEDIA_TYPE = 67i32;
7025 pub const HITACHI_12_WO: STORAGE_MEDIA_TYPE = 68i32;
7026 pub const CYGNET_12_WO: STORAGE_MEDIA_TYPE = 69i32;
7027 pub const KODAK_14_WO: STORAGE_MEDIA_TYPE = 70i32;
7028 pub const MO_NFR_525: STORAGE_MEDIA_TYPE = 71i32;
7029 pub const NIKON_12_RW: STORAGE_MEDIA_TYPE = 72i32;
7030 pub const IOMEGA_ZIP: STORAGE_MEDIA_TYPE = 73i32;
7031 pub const IOMEGA_JAZ: STORAGE_MEDIA_TYPE = 74i32;
7032 pub const SYQUEST_EZ135: STORAGE_MEDIA_TYPE = 75i32;
7033 pub const SYQUEST_EZFLYER: STORAGE_MEDIA_TYPE = 76i32;
7034 pub const SYQUEST_SYJET: STORAGE_MEDIA_TYPE = 77i32;
7035 pub const AVATAR_F2: STORAGE_MEDIA_TYPE = 78i32;
7036 pub const MP2_8mm: STORAGE_MEDIA_TYPE = 79i32;
7037 pub const DST_S: STORAGE_MEDIA_TYPE = 80i32;
7038 pub const DST_M: STORAGE_MEDIA_TYPE = 81i32;
7039 pub const DST_L: STORAGE_MEDIA_TYPE = 82i32;
7040 pub const VXATape_1: STORAGE_MEDIA_TYPE = 83i32;
7041 pub const VXATape_2: STORAGE_MEDIA_TYPE = 84i32;
7042 pub const STK_9840: STORAGE_MEDIA_TYPE = 85i32;
7043 pub const LTO_Ultrium: STORAGE_MEDIA_TYPE = 86i32;
7044 pub const LTO_Accelis: STORAGE_MEDIA_TYPE = 87i32;
7045 pub const DVD_RAM: STORAGE_MEDIA_TYPE = 88i32;
7046 pub const AIT_8mm: STORAGE_MEDIA_TYPE = 89i32;
7047 pub const ADR_1: STORAGE_MEDIA_TYPE = 90i32;
7048 pub const ADR_2: STORAGE_MEDIA_TYPE = 91i32;
7049 pub const STK_9940: STORAGE_MEDIA_TYPE = 92i32;
7050 pub const SAIT: STORAGE_MEDIA_TYPE = 93i32;
7051 pub const VXATape: STORAGE_MEDIA_TYPE = 94i32;
7052 #[repr(C)]
7053 pub struct STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR {
7054     pub Version: u32,
7055     pub Size: u32,
7056     pub MediumProductType: u32,
7057 }
7058 impl ::core::marker::Copy for STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR {}
7059 impl ::core::clone::Clone for STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR {
7060     fn clone(&self) -> Self {
7061         *self
7062     }
7063 }
7064 #[repr(C)]
7065 #[cfg(feature = "Win32_Foundation")]
7066 pub struct STORAGE_MINIPORT_DESCRIPTOR {
7067     pub Version: u32,
7068     pub Size: u32,
7069     pub Portdriver: STORAGE_PORT_CODE_SET,
7070     pub LUNResetSupported: super::super::Foundation::BOOLEAN,
7071     pub TargetResetSupported: super::super::Foundation::BOOLEAN,
7072     pub IoTimeoutValue: u16,
7073     pub ExtraIoInfoSupported: super::super::Foundation::BOOLEAN,
7074     pub Flags: STORAGE_MINIPORT_DESCRIPTOR_0,
7075     pub Reserved0: [u8; 2],
7076     pub Reserved1: u32,
7077 }
7078 #[cfg(feature = "Win32_Foundation")]
7079 impl ::core::marker::Copy for STORAGE_MINIPORT_DESCRIPTOR {}
7080 #[cfg(feature = "Win32_Foundation")]
7081 impl ::core::clone::Clone for STORAGE_MINIPORT_DESCRIPTOR {
7082     fn clone(&self) -> Self {
7083         *self
7084     }
7085 }
7086 #[repr(C)]
7087 #[cfg(feature = "Win32_Foundation")]
7088 pub union STORAGE_MINIPORT_DESCRIPTOR_0 {
7089     pub Anonymous: STORAGE_MINIPORT_DESCRIPTOR_0_0,
7090     pub AsBYTE: u8,
7091 }
7092 #[cfg(feature = "Win32_Foundation")]
7093 impl ::core::marker::Copy for STORAGE_MINIPORT_DESCRIPTOR_0 {}
7094 #[cfg(feature = "Win32_Foundation")]
7095 impl ::core::clone::Clone for STORAGE_MINIPORT_DESCRIPTOR_0 {
7096     fn clone(&self) -> Self {
7097         *self
7098     }
7099 }
7100 #[repr(C)]
7101 #[cfg(feature = "Win32_Foundation")]
7102 pub struct STORAGE_MINIPORT_DESCRIPTOR_0_0 {
7103     pub _bitfield: u8,
7104 }
7105 #[cfg(feature = "Win32_Foundation")]
7106 impl ::core::marker::Copy for STORAGE_MINIPORT_DESCRIPTOR_0_0 {}
7107 #[cfg(feature = "Win32_Foundation")]
7108 impl ::core::clone::Clone for STORAGE_MINIPORT_DESCRIPTOR_0_0 {
7109     fn clone(&self) -> Self {
7110         *self
7111     }
7112 }
7113 pub const STORAGE_OFFLOAD_MAX_TOKEN_LENGTH: u32 = 512u32;
7114 #[repr(C)]
7115 pub struct STORAGE_OFFLOAD_READ_OUTPUT {
7116     pub OffloadReadFlags: u32,
7117     pub Reserved: u32,
7118     pub LengthProtected: u64,
7119     pub TokenLength: u32,
7120     pub Token: STORAGE_OFFLOAD_TOKEN,
7121 }
7122 impl ::core::marker::Copy for STORAGE_OFFLOAD_READ_OUTPUT {}
7123 impl ::core::clone::Clone for STORAGE_OFFLOAD_READ_OUTPUT {
7124     fn clone(&self) -> Self {
7125         *self
7126     }
7127 }
7128 pub const STORAGE_OFFLOAD_READ_RANGE_TRUNCATED: u32 = 1u32;
7129 #[repr(C)]
7130 pub struct STORAGE_OFFLOAD_TOKEN {
7131     pub TokenType: [u8; 4],
7132     pub Reserved: [u8; 2],
7133     pub TokenIdLength: [u8; 2],
7134     pub Anonymous: STORAGE_OFFLOAD_TOKEN_0,
7135 }
7136 impl ::core::marker::Copy for STORAGE_OFFLOAD_TOKEN {}
7137 impl ::core::clone::Clone for STORAGE_OFFLOAD_TOKEN {
7138     fn clone(&self) -> Self {
7139         *self
7140     }
7141 }
7142 #[repr(C)]
7143 pub union STORAGE_OFFLOAD_TOKEN_0 {
7144     pub StorageOffloadZeroDataToken: STORAGE_OFFLOAD_TOKEN_0_0,
7145     pub Token: [u8; 504],
7146 }
7147 impl ::core::marker::Copy for STORAGE_OFFLOAD_TOKEN_0 {}
7148 impl ::core::clone::Clone for STORAGE_OFFLOAD_TOKEN_0 {
7149     fn clone(&self) -> Self {
7150         *self
7151     }
7152 }
7153 #[repr(C)]
7154 pub struct STORAGE_OFFLOAD_TOKEN_0_0 {
7155     pub Reserved2: [u8; 504],
7156 }
7157 impl ::core::marker::Copy for STORAGE_OFFLOAD_TOKEN_0_0 {}
7158 impl ::core::clone::Clone for STORAGE_OFFLOAD_TOKEN_0_0 {
7159     fn clone(&self) -> Self {
7160         *self
7161     }
7162 }
7163 pub const STORAGE_OFFLOAD_TOKEN_ID_LENGTH: u32 = 504u32;
7164 pub const STORAGE_OFFLOAD_TOKEN_INVALID: u32 = 2u32;
7165 pub const STORAGE_OFFLOAD_TOKEN_TYPE_ZERO_DATA: u32 = 4294901761u32;
7166 #[repr(C)]
7167 pub struct STORAGE_OFFLOAD_WRITE_OUTPUT {
7168     pub OffloadWriteFlags: u32,
7169     pub Reserved: u32,
7170     pub LengthCopied: u64,
7171 }
7172 impl ::core::marker::Copy for STORAGE_OFFLOAD_WRITE_OUTPUT {}
7173 impl ::core::clone::Clone for STORAGE_OFFLOAD_WRITE_OUTPUT {
7174     fn clone(&self) -> Self {
7175         *self
7176     }
7177 }
7178 pub const STORAGE_OFFLOAD_WRITE_RANGE_TRUNCATED: u32 = 1u32;
7179 #[repr(C)]
7180 pub struct STORAGE_OPERATIONAL_REASON {
7181     pub Version: u32,
7182     pub Size: u32,
7183     pub Reason: STORAGE_OPERATIONAL_STATUS_REASON,
7184     pub RawBytes: STORAGE_OPERATIONAL_REASON_0,
7185 }
7186 impl ::core::marker::Copy for STORAGE_OPERATIONAL_REASON {}
7187 impl ::core::clone::Clone for STORAGE_OPERATIONAL_REASON {
7188     fn clone(&self) -> Self {
7189         *self
7190     }
7191 }
7192 #[repr(C)]
7193 pub union STORAGE_OPERATIONAL_REASON_0 {
7194     pub ScsiSenseKey: STORAGE_OPERATIONAL_REASON_0_1,
7195     pub NVDIMM_N: STORAGE_OPERATIONAL_REASON_0_0,
7196     pub AsUlong: u32,
7197 }
7198 impl ::core::marker::Copy for STORAGE_OPERATIONAL_REASON_0 {}
7199 impl ::core::clone::Clone for STORAGE_OPERATIONAL_REASON_0 {
7200     fn clone(&self) -> Self {
7201         *self
7202     }
7203 }
7204 #[repr(C)]
7205 pub struct STORAGE_OPERATIONAL_REASON_0_0 {
7206     pub CriticalHealth: u8,
7207     pub ModuleHealth: [u8; 2],
7208     pub ErrorThresholdStatus: u8,
7209 }
7210 impl ::core::marker::Copy for STORAGE_OPERATIONAL_REASON_0_0 {}
7211 impl ::core::clone::Clone for STORAGE_OPERATIONAL_REASON_0_0 {
7212     fn clone(&self) -> Self {
7213         *self
7214     }
7215 }
7216 #[repr(C)]
7217 pub struct STORAGE_OPERATIONAL_REASON_0_1 {
7218     pub SenseKey: u8,
7219     pub ASC: u8,
7220     pub ASCQ: u8,
7221     pub Reserved: u8,
7222 }
7223 impl ::core::marker::Copy for STORAGE_OPERATIONAL_REASON_0_1 {}
7224 impl ::core::clone::Clone for STORAGE_OPERATIONAL_REASON_0_1 {
7225     fn clone(&self) -> Self {
7226         *self
7227     }
7228 }
7229 pub type STORAGE_OPERATIONAL_STATUS_REASON = i32;
7230 pub const DiskOpReasonUnknown: STORAGE_OPERATIONAL_STATUS_REASON = 0i32;
7231 pub const DiskOpReasonScsiSenseCode: STORAGE_OPERATIONAL_STATUS_REASON = 1i32;
7232 pub const DiskOpReasonMedia: STORAGE_OPERATIONAL_STATUS_REASON = 2i32;
7233 pub const DiskOpReasonIo: STORAGE_OPERATIONAL_STATUS_REASON = 3i32;
7234 pub const DiskOpReasonThresholdExceeded: STORAGE_OPERATIONAL_STATUS_REASON = 4i32;
7235 pub const DiskOpReasonLostData: STORAGE_OPERATIONAL_STATUS_REASON = 5i32;
7236 pub const DiskOpReasonEnergySource: STORAGE_OPERATIONAL_STATUS_REASON = 6i32;
7237 pub const DiskOpReasonConfiguration: STORAGE_OPERATIONAL_STATUS_REASON = 7i32;
7238 pub const DiskOpReasonDeviceController: STORAGE_OPERATIONAL_STATUS_REASON = 8i32;
7239 pub const DiskOpReasonMediaController: STORAGE_OPERATIONAL_STATUS_REASON = 9i32;
7240 pub const DiskOpReasonComponent: STORAGE_OPERATIONAL_STATUS_REASON = 10i32;
7241 pub const DiskOpReasonNVDIMM_N: STORAGE_OPERATIONAL_STATUS_REASON = 11i32;
7242 pub const DiskOpReasonBackgroundOperation: STORAGE_OPERATIONAL_STATUS_REASON = 12i32;
7243 pub const DiskOpReasonInvalidFirmware: STORAGE_OPERATIONAL_STATUS_REASON = 13i32;
7244 pub const DiskOpReasonHealthCheck: STORAGE_OPERATIONAL_STATUS_REASON = 14i32;
7245 pub const DiskOpReasonLostDataPersistence: STORAGE_OPERATIONAL_STATUS_REASON = 15i32;
7246 pub const DiskOpReasonDisabledByPlatform: STORAGE_OPERATIONAL_STATUS_REASON = 16i32;
7247 pub const DiskOpReasonLostWritePersistence: STORAGE_OPERATIONAL_STATUS_REASON = 17i32;
7248 pub const DiskOpReasonDataPersistenceLossImminent: STORAGE_OPERATIONAL_STATUS_REASON = 18i32;
7249 pub const DiskOpReasonWritePersistenceLossImminent: STORAGE_OPERATIONAL_STATUS_REASON = 19i32;
7250 pub const DiskOpReasonMax: STORAGE_OPERATIONAL_STATUS_REASON = 20i32;
7251 #[repr(C)]
7252 #[cfg(feature = "Win32_Foundation")]
7253 pub struct STORAGE_PHYSICAL_ADAPTER_DATA {
7254     pub AdapterId: u32,
7255     pub HealthStatus: STORAGE_COMPONENT_HEALTH_STATUS,
7256     pub CommandProtocol: STORAGE_PROTOCOL_TYPE,
7257     pub SpecVersion: STORAGE_SPEC_VERSION,
7258     pub Vendor: [u8; 8],
7259     pub Model: [u8; 40],
7260     pub FirmwareRevision: [u8; 16],
7261     pub PhysicalLocation: [u8; 32],
7262     pub ExpanderConnected: super::super::Foundation::BOOLEAN,
7263     pub Reserved0: [u8; 3],
7264     pub Reserved1: [u32; 3],
7265 }
7266 #[cfg(feature = "Win32_Foundation")]
7267 impl ::core::marker::Copy for STORAGE_PHYSICAL_ADAPTER_DATA {}
7268 #[cfg(feature = "Win32_Foundation")]
7269 impl ::core::clone::Clone for STORAGE_PHYSICAL_ADAPTER_DATA {
7270     fn clone(&self) -> Self {
7271         *self
7272     }
7273 }
7274 #[repr(C)]
7275 pub struct STORAGE_PHYSICAL_DEVICE_DATA {
7276     pub DeviceId: u32,
7277     pub Role: u32,
7278     pub HealthStatus: STORAGE_COMPONENT_HEALTH_STATUS,
7279     pub CommandProtocol: STORAGE_PROTOCOL_TYPE,
7280     pub SpecVersion: STORAGE_SPEC_VERSION,
7281     pub FormFactor: STORAGE_DEVICE_FORM_FACTOR,
7282     pub Vendor: [u8; 8],
7283     pub Model: [u8; 40],
7284     pub FirmwareRevision: [u8; 16],
7285     pub Capacity: u64,
7286     pub PhysicalLocation: [u8; 32],
7287     pub Reserved: [u32; 2],
7288 }
7289 impl ::core::marker::Copy for STORAGE_PHYSICAL_DEVICE_DATA {}
7290 impl ::core::clone::Clone for STORAGE_PHYSICAL_DEVICE_DATA {
7291     fn clone(&self) -> Self {
7292         *self
7293     }
7294 }
7295 #[repr(C)]
7296 pub struct STORAGE_PHYSICAL_NODE_DATA {
7297     pub NodeId: u32,
7298     pub AdapterCount: u32,
7299     pub AdapterDataLength: u32,
7300     pub AdapterDataOffset: u32,
7301     pub DeviceCount: u32,
7302     pub DeviceDataLength: u32,
7303     pub DeviceDataOffset: u32,
7304     pub Reserved: [u32; 3],
7305 }
7306 impl ::core::marker::Copy for STORAGE_PHYSICAL_NODE_DATA {}
7307 impl ::core::clone::Clone for STORAGE_PHYSICAL_NODE_DATA {
7308     fn clone(&self) -> Self {
7309         *self
7310     }
7311 }
7312 #[repr(C)]
7313 pub struct STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR {
7314     pub Version: u32,
7315     pub Size: u32,
7316     pub NodeCount: u32,
7317     pub Reserved: u32,
7318     pub Node: [STORAGE_PHYSICAL_NODE_DATA; 1],
7319 }
7320 impl ::core::marker::Copy for STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR {}
7321 impl ::core::clone::Clone for STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR {
7322     fn clone(&self) -> Self {
7323         *self
7324     }
7325 }
7326 pub type STORAGE_PORT_CODE_SET = i32;
7327 pub const StoragePortCodeSetReserved: STORAGE_PORT_CODE_SET = 0i32;
7328 pub const StoragePortCodeSetStorport: STORAGE_PORT_CODE_SET = 1i32;
7329 pub const StoragePortCodeSetSCSIport: STORAGE_PORT_CODE_SET = 2i32;
7330 pub const StoragePortCodeSetSpaceport: STORAGE_PORT_CODE_SET = 3i32;
7331 pub const StoragePortCodeSetATAport: STORAGE_PORT_CODE_SET = 4i32;
7332 pub const StoragePortCodeSetUSBport: STORAGE_PORT_CODE_SET = 5i32;
7333 pub const StoragePortCodeSetSBP2port: STORAGE_PORT_CODE_SET = 6i32;
7334 pub const StoragePortCodeSetSDport: STORAGE_PORT_CODE_SET = 7i32;
7335 pub type STORAGE_POWERUP_REASON_TYPE = i32;
7336 pub const StoragePowerupUnknown: STORAGE_POWERUP_REASON_TYPE = 0i32;
7337 pub const StoragePowerupIO: STORAGE_POWERUP_REASON_TYPE = 1i32;
7338 pub const StoragePowerupDeviceAttention: STORAGE_POWERUP_REASON_TYPE = 2i32;
7339 #[repr(C)]
7340 pub struct STORAGE_PREDICT_FAILURE {
7341     pub PredictFailure: u32,
7342     pub VendorSpecific: [u8; 512],
7343 }
7344 impl ::core::marker::Copy for STORAGE_PREDICT_FAILURE {}
7345 impl ::core::clone::Clone for STORAGE_PREDICT_FAILURE {
7346     fn clone(&self) -> Self {
7347         *self
7348     }
7349 }
7350 #[repr(C)]
7351 pub struct STORAGE_PRIORITY_HINT_SUPPORT {
7352     pub SupportFlags: u32,
7353 }
7354 impl ::core::marker::Copy for STORAGE_PRIORITY_HINT_SUPPORT {}
7355 impl ::core::clone::Clone for STORAGE_PRIORITY_HINT_SUPPORT {
7356     fn clone(&self) -> Self {
7357         *self
7358     }
7359 }
7360 pub const STORAGE_PRIORITY_HINT_SUPPORTED: u32 = 1u32;
7361 pub type STORAGE_PROPERTY_ID = i32;
7362 pub const StorageDeviceProperty: STORAGE_PROPERTY_ID = 0i32;
7363 pub const StorageAdapterProperty: STORAGE_PROPERTY_ID = 1i32;
7364 pub const StorageDeviceIdProperty: STORAGE_PROPERTY_ID = 2i32;
7365 pub const StorageDeviceUniqueIdProperty: STORAGE_PROPERTY_ID = 3i32;
7366 pub const StorageDeviceWriteCacheProperty: STORAGE_PROPERTY_ID = 4i32;
7367 pub const StorageMiniportProperty: STORAGE_PROPERTY_ID = 5i32;
7368 pub const StorageAccessAlignmentProperty: STORAGE_PROPERTY_ID = 6i32;
7369 pub const StorageDeviceSeekPenaltyProperty: STORAGE_PROPERTY_ID = 7i32;
7370 pub const StorageDeviceTrimProperty: STORAGE_PROPERTY_ID = 8i32;
7371 pub const StorageDeviceWriteAggregationProperty: STORAGE_PROPERTY_ID = 9i32;
7372 pub const StorageDeviceDeviceTelemetryProperty: STORAGE_PROPERTY_ID = 10i32;
7373 pub const StorageDeviceLBProvisioningProperty: STORAGE_PROPERTY_ID = 11i32;
7374 pub const StorageDevicePowerProperty: STORAGE_PROPERTY_ID = 12i32;
7375 pub const StorageDeviceCopyOffloadProperty: STORAGE_PROPERTY_ID = 13i32;
7376 pub const StorageDeviceResiliencyProperty: STORAGE_PROPERTY_ID = 14i32;
7377 pub const StorageDeviceMediumProductType: STORAGE_PROPERTY_ID = 15i32;
7378 pub const StorageAdapterRpmbProperty: STORAGE_PROPERTY_ID = 16i32;
7379 pub const StorageAdapterCryptoProperty: STORAGE_PROPERTY_ID = 17i32;
7380 pub const StorageDeviceIoCapabilityProperty: STORAGE_PROPERTY_ID = 48i32;
7381 pub const StorageAdapterProtocolSpecificProperty: STORAGE_PROPERTY_ID = 49i32;
7382 pub const StorageDeviceProtocolSpecificProperty: STORAGE_PROPERTY_ID = 50i32;
7383 pub const StorageAdapterTemperatureProperty: STORAGE_PROPERTY_ID = 51i32;
7384 pub const StorageDeviceTemperatureProperty: STORAGE_PROPERTY_ID = 52i32;
7385 pub const StorageAdapterPhysicalTopologyProperty: STORAGE_PROPERTY_ID = 53i32;
7386 pub const StorageDevicePhysicalTopologyProperty: STORAGE_PROPERTY_ID = 54i32;
7387 pub const StorageDeviceAttributesProperty: STORAGE_PROPERTY_ID = 55i32;
7388 pub const StorageDeviceManagementStatus: STORAGE_PROPERTY_ID = 56i32;
7389 pub const StorageAdapterSerialNumberProperty: STORAGE_PROPERTY_ID = 57i32;
7390 pub const StorageDeviceLocationProperty: STORAGE_PROPERTY_ID = 58i32;
7391 pub const StorageDeviceNumaProperty: STORAGE_PROPERTY_ID = 59i32;
7392 pub const StorageDeviceZonedDeviceProperty: STORAGE_PROPERTY_ID = 60i32;
7393 pub const StorageDeviceUnsafeShutdownCount: STORAGE_PROPERTY_ID = 61i32;
7394 pub const StorageDeviceEnduranceProperty: STORAGE_PROPERTY_ID = 62i32;
7395 pub const StorageDeviceLedStateProperty: STORAGE_PROPERTY_ID = 63i32;
7396 pub const StorageDeviceSelfEncryptionProperty: STORAGE_PROPERTY_ID = 64i32;
7397 pub const StorageFruIdProperty: STORAGE_PROPERTY_ID = 65i32;
7398 #[repr(C)]
7399 pub struct STORAGE_PROPERTY_QUERY {
7400     pub PropertyId: STORAGE_PROPERTY_ID,
7401     pub QueryType: STORAGE_QUERY_TYPE,
7402     pub AdditionalParameters: [u8; 1],
7403 }
7404 impl ::core::marker::Copy for STORAGE_PROPERTY_QUERY {}
7405 impl ::core::clone::Clone for STORAGE_PROPERTY_QUERY {
7406     fn clone(&self) -> Self {
7407         *self
7408     }
7409 }
7410 #[repr(C)]
7411 pub struct STORAGE_PROPERTY_SET {
7412     pub PropertyId: STORAGE_PROPERTY_ID,
7413     pub SetType: STORAGE_SET_TYPE,
7414     pub AdditionalParameters: [u8; 1],
7415 }
7416 impl ::core::marker::Copy for STORAGE_PROPERTY_SET {}
7417 impl ::core::clone::Clone for STORAGE_PROPERTY_SET {
7418     fn clone(&self) -> Self {
7419         *self
7420     }
7421 }
7422 pub type STORAGE_PROTOCOL_ATA_DATA_TYPE = i32;
7423 pub const AtaDataTypeUnknown: STORAGE_PROTOCOL_ATA_DATA_TYPE = 0i32;
7424 pub const AtaDataTypeIdentify: STORAGE_PROTOCOL_ATA_DATA_TYPE = 1i32;
7425 pub const AtaDataTypeLogPage: STORAGE_PROTOCOL_ATA_DATA_TYPE = 2i32;
7426 #[repr(C)]
7427 pub struct STORAGE_PROTOCOL_COMMAND {
7428     pub Version: u32,
7429     pub Length: u32,
7430     pub ProtocolType: STORAGE_PROTOCOL_TYPE,
7431     pub Flags: u32,
7432     pub ReturnStatus: u32,
7433     pub ErrorCode: u32,
7434     pub CommandLength: u32,
7435     pub ErrorInfoLength: u32,
7436     pub DataToDeviceTransferLength: u32,
7437     pub DataFromDeviceTransferLength: u32,
7438     pub TimeOutValue: u32,
7439     pub ErrorInfoOffset: u32,
7440     pub DataToDeviceBufferOffset: u32,
7441     pub DataFromDeviceBufferOffset: u32,
7442     pub CommandSpecific: u32,
7443     pub Reserved0: u32,
7444     pub FixedProtocolReturnData: u32,
7445     pub Reserved1: [u32; 3],
7446     pub Command: [u8; 1],
7447 }
7448 impl ::core::marker::Copy for STORAGE_PROTOCOL_COMMAND {}
7449 impl ::core::clone::Clone for STORAGE_PROTOCOL_COMMAND {
7450     fn clone(&self) -> Self {
7451         *self
7452     }
7453 }
7454 pub const STORAGE_PROTOCOL_COMMAND_FLAG_ADAPTER_REQUEST: u32 = 2147483648u32;
7455 pub const STORAGE_PROTOCOL_COMMAND_LENGTH_NVME: u32 = 64u32;
7456 #[repr(C)]
7457 pub struct STORAGE_PROTOCOL_DATA_DESCRIPTOR {
7458     pub Version: u32,
7459     pub Size: u32,
7460     pub ProtocolSpecificData: STORAGE_PROTOCOL_SPECIFIC_DATA,
7461 }
7462 impl ::core::marker::Copy for STORAGE_PROTOCOL_DATA_DESCRIPTOR {}
7463 impl ::core::clone::Clone for STORAGE_PROTOCOL_DATA_DESCRIPTOR {
7464     fn clone(&self) -> Self {
7465         *self
7466     }
7467 }
7468 #[repr(C)]
7469 pub struct STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT {
7470     pub Version: u32,
7471     pub Size: u32,
7472     pub ProtocolSpecificData: STORAGE_PROTOCOL_SPECIFIC_DATA_EXT,
7473 }
7474 impl ::core::marker::Copy for STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT {}
7475 impl ::core::clone::Clone for STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT {
7476     fn clone(&self) -> Self {
7477         *self
7478     }
7479 }
7480 #[repr(C)]
7481 pub union STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE {
7482     pub Anonymous: STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE_0,
7483     pub AsUlong: u32,
7484 }
7485 impl ::core::marker::Copy for STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE {}
7486 impl ::core::clone::Clone for STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE {
7487     fn clone(&self) -> Self {
7488         *self
7489     }
7490 }
7491 #[repr(C)]
7492 pub struct STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE_0 {
7493     pub _bitfield: u32,
7494 }
7495 impl ::core::marker::Copy for STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE_0 {}
7496 impl ::core::clone::Clone for STORAGE_PROTOCOL_DATA_SUBVALUE_GET_LOG_PAGE_0 {
7497     fn clone(&self) -> Self {
7498         *self
7499     }
7500 }
7501 pub type STORAGE_PROTOCOL_NVME_DATA_TYPE = i32;
7502 pub const NVMeDataTypeUnknown: STORAGE_PROTOCOL_NVME_DATA_TYPE = 0i32;
7503 pub const NVMeDataTypeIdentify: STORAGE_PROTOCOL_NVME_DATA_TYPE = 1i32;
7504 pub const NVMeDataTypeLogPage: STORAGE_PROTOCOL_NVME_DATA_TYPE = 2i32;
7505 pub const NVMeDataTypeFeature: STORAGE_PROTOCOL_NVME_DATA_TYPE = 3i32;
7506 #[repr(C)]
7507 pub struct STORAGE_PROTOCOL_SPECIFIC_DATA {
7508     pub ProtocolType: STORAGE_PROTOCOL_TYPE,
7509     pub DataType: u32,
7510     pub ProtocolDataRequestValue: u32,
7511     pub ProtocolDataRequestSubValue: u32,
7512     pub ProtocolDataOffset: u32,
7513     pub ProtocolDataLength: u32,
7514     pub FixedProtocolReturnData: u32,
7515     pub ProtocolDataRequestSubValue2: u32,
7516     pub ProtocolDataRequestSubValue3: u32,
7517     pub ProtocolDataRequestSubValue4: u32,
7518 }
7519 impl ::core::marker::Copy for STORAGE_PROTOCOL_SPECIFIC_DATA {}
7520 impl ::core::clone::Clone for STORAGE_PROTOCOL_SPECIFIC_DATA {
7521     fn clone(&self) -> Self {
7522         *self
7523     }
7524 }
7525 #[repr(C)]
7526 pub struct STORAGE_PROTOCOL_SPECIFIC_DATA_EXT {
7527     pub ProtocolType: STORAGE_PROTOCOL_TYPE,
7528     pub DataType: u32,
7529     pub ProtocolDataValue: u32,
7530     pub ProtocolDataSubValue: u32,
7531     pub ProtocolDataOffset: u32,
7532     pub ProtocolDataLength: u32,
7533     pub FixedProtocolReturnData: u32,
7534     pub ProtocolDataSubValue2: u32,
7535     pub ProtocolDataSubValue3: u32,
7536     pub ProtocolDataSubValue4: u32,
7537     pub ProtocolDataSubValue5: u32,
7538     pub Reserved: [u32; 5],
7539 }
7540 impl ::core::marker::Copy for STORAGE_PROTOCOL_SPECIFIC_DATA_EXT {}
7541 impl ::core::clone::Clone for STORAGE_PROTOCOL_SPECIFIC_DATA_EXT {
7542     fn clone(&self) -> Self {
7543         *self
7544     }
7545 }
7546 pub const STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND: u32 = 1u32;
7547 pub const STORAGE_PROTOCOL_SPECIFIC_NVME_NVM_COMMAND: u32 = 2u32;
7548 pub const STORAGE_PROTOCOL_STATUS_BUSY: u32 = 5u32;
7549 pub const STORAGE_PROTOCOL_STATUS_DATA_OVERRUN: u32 = 6u32;
7550 pub const STORAGE_PROTOCOL_STATUS_ERROR: u32 = 2u32;
7551 pub const STORAGE_PROTOCOL_STATUS_INSUFFICIENT_RESOURCES: u32 = 7u32;
7552 pub const STORAGE_PROTOCOL_STATUS_INVALID_REQUEST: u32 = 3u32;
7553 pub const STORAGE_PROTOCOL_STATUS_NOT_SUPPORTED: u32 = 255u32;
7554 pub const STORAGE_PROTOCOL_STATUS_NO_DEVICE: u32 = 4u32;
7555 pub const STORAGE_PROTOCOL_STATUS_PENDING: u32 = 0u32;
7556 pub const STORAGE_PROTOCOL_STATUS_SUCCESS: u32 = 1u32;
7557 pub const STORAGE_PROTOCOL_STATUS_THROTTLED_REQUEST: u32 = 8u32;
7558 pub const STORAGE_PROTOCOL_STRUCTURE_VERSION: u32 = 1u32;
7559 pub type STORAGE_PROTOCOL_TYPE = i32;
7560 pub const ProtocolTypeUnknown: STORAGE_PROTOCOL_TYPE = 0i32;
7561 pub const ProtocolTypeScsi: STORAGE_PROTOCOL_TYPE = 1i32;
7562 pub const ProtocolTypeAta: STORAGE_PROTOCOL_TYPE = 2i32;
7563 pub const ProtocolTypeNvme: STORAGE_PROTOCOL_TYPE = 3i32;
7564 pub const ProtocolTypeSd: STORAGE_PROTOCOL_TYPE = 4i32;
7565 pub const ProtocolTypeUfs: STORAGE_PROTOCOL_TYPE = 5i32;
7566 pub const ProtocolTypeProprietary: STORAGE_PROTOCOL_TYPE = 126i32;
7567 pub const ProtocolTypeMaxReserved: STORAGE_PROTOCOL_TYPE = 127i32;
7568 pub type STORAGE_PROTOCOL_UFS_DATA_TYPE = i32;
7569 pub const UfsDataTypeUnknown: STORAGE_PROTOCOL_UFS_DATA_TYPE = 0i32;
7570 pub const UfsDataTypeQueryDescriptor: STORAGE_PROTOCOL_UFS_DATA_TYPE = 1i32;
7571 pub const UfsDataTypeQueryAttribute: STORAGE_PROTOCOL_UFS_DATA_TYPE = 2i32;
7572 pub const UfsDataTypeQueryFlag: STORAGE_PROTOCOL_UFS_DATA_TYPE = 3i32;
7573 pub const UfsDataTypeQueryDmeAttribute: STORAGE_PROTOCOL_UFS_DATA_TYPE = 4i32;
7574 pub const UfsDataTypeQueryDmePeerAttribute: STORAGE_PROTOCOL_UFS_DATA_TYPE = 5i32;
7575 pub const UfsDataTypeMax: STORAGE_PROTOCOL_UFS_DATA_TYPE = 6i32;
7576 #[repr(C)]
7577 #[cfg(feature = "Win32_Storage_Vhd")]
7578 pub struct STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY {
7579     pub EntryLength: u32,
7580     pub DependencyTypeFlags: u32,
7581     pub ProviderSpecificFlags: u32,
7582     pub VirtualStorageType: super::super::Storage::Vhd::VIRTUAL_STORAGE_TYPE,
7583 }
7584 #[cfg(feature = "Win32_Storage_Vhd")]
7585 impl ::core::marker::Copy for STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY {}
7586 #[cfg(feature = "Win32_Storage_Vhd")]
7587 impl ::core::clone::Clone for STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY {
7588     fn clone(&self) -> Self {
7589         *self
7590     }
7591 }
7592 #[repr(C)]
7593 #[cfg(feature = "Win32_Storage_Vhd")]
7594 pub struct STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY {
7595     pub EntryLength: u32,
7596     pub DependencyTypeFlags: u32,
7597     pub ProviderSpecificFlags: u32,
7598     pub VirtualStorageType: super::super::Storage::Vhd::VIRTUAL_STORAGE_TYPE,
7599     pub AncestorLevel: u32,
7600     pub HostVolumeNameOffset: u32,
7601     pub HostVolumeNameSize: u32,
7602     pub DependentVolumeNameOffset: u32,
7603     pub DependentVolumeNameSize: u32,
7604     pub RelativePathOffset: u32,
7605     pub RelativePathSize: u32,
7606     pub DependentDeviceNameOffset: u32,
7607     pub DependentDeviceNameSize: u32,
7608 }
7609 #[cfg(feature = "Win32_Storage_Vhd")]
7610 impl ::core::marker::Copy for STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY {}
7611 #[cfg(feature = "Win32_Storage_Vhd")]
7612 impl ::core::clone::Clone for STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY {
7613     fn clone(&self) -> Self {
7614         *self
7615     }
7616 }
7617 #[repr(C)]
7618 pub struct STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST {
7619     pub RequestLevel: u32,
7620     pub RequestFlags: u32,
7621 }
7622 impl ::core::marker::Copy for STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST {}
7623 impl ::core::clone::Clone for STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST {
7624     fn clone(&self) -> Self {
7625         *self
7626     }
7627 }
7628 #[repr(C)]
7629 #[cfg(feature = "Win32_Storage_Vhd")]
7630 pub struct STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE {
7631     pub ResponseLevel: u32,
7632     pub NumberEntries: u32,
7633     pub Anonymous: STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE_0,
7634 }
7635 #[cfg(feature = "Win32_Storage_Vhd")]
7636 impl ::core::marker::Copy for STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE {}
7637 #[cfg(feature = "Win32_Storage_Vhd")]
7638 impl ::core::clone::Clone for STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE {
7639     fn clone(&self) -> Self {
7640         *self
7641     }
7642 }
7643 #[repr(C)]
7644 #[cfg(feature = "Win32_Storage_Vhd")]
7645 pub union STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE_0 {
7646     pub Lev1Depends: [STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY; 1],
7647     pub Lev2Depends: [STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY; 1],
7648 }
7649 #[cfg(feature = "Win32_Storage_Vhd")]
7650 impl ::core::marker::Copy for STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE_0 {}
7651 #[cfg(feature = "Win32_Storage_Vhd")]
7652 impl ::core::clone::Clone for STORAGE_QUERY_DEPENDENT_VOLUME_RESPONSE_0 {
7653     fn clone(&self) -> Self {
7654         *self
7655     }
7656 }
7657 pub type STORAGE_QUERY_TYPE = i32;
7658 pub const PropertyStandardQuery: STORAGE_QUERY_TYPE = 0i32;
7659 pub const PropertyExistsQuery: STORAGE_QUERY_TYPE = 1i32;
7660 pub const PropertyMaskQuery: STORAGE_QUERY_TYPE = 2i32;
7661 pub const PropertyQueryMaxDefined: STORAGE_QUERY_TYPE = 3i32;
7662 #[repr(C)]
7663 pub struct STORAGE_READ_CAPACITY {
7664     pub Version: u32,
7665     pub Size: u32,
7666     pub BlockLength: u32,
7667     pub NumberOfBlocks: i64,
7668     pub DiskLength: i64,
7669 }
7670 impl ::core::marker::Copy for STORAGE_READ_CAPACITY {}
7671 impl ::core::clone::Clone for STORAGE_READ_CAPACITY {
7672     fn clone(&self) -> Self {
7673         *self
7674     }
7675 }
7676 #[repr(C)]
7677 pub struct STORAGE_REINITIALIZE_MEDIA {
7678     pub Version: u32,
7679     pub Size: u32,
7680     pub TimeoutInSeconds: u32,
7681     pub SanitizeOption: STORAGE_REINITIALIZE_MEDIA_0,
7682 }
7683 impl ::core::marker::Copy for STORAGE_REINITIALIZE_MEDIA {}
7684 impl ::core::clone::Clone for STORAGE_REINITIALIZE_MEDIA {
7685     fn clone(&self) -> Self {
7686         *self
7687     }
7688 }
7689 #[repr(C)]
7690 pub struct STORAGE_REINITIALIZE_MEDIA_0 {
7691     pub _bitfield: u32,
7692 }
7693 impl ::core::marker::Copy for STORAGE_REINITIALIZE_MEDIA_0 {}
7694 impl ::core::clone::Clone for STORAGE_REINITIALIZE_MEDIA_0 {
7695     fn clone(&self) -> Self {
7696         *self
7697     }
7698 }
7699 pub type STORAGE_RESERVE_ID = i32;
7700 pub const StorageReserveIdNone: STORAGE_RESERVE_ID = 0i32;
7701 pub const StorageReserveIdHard: STORAGE_RESERVE_ID = 1i32;
7702 pub const StorageReserveIdSoft: STORAGE_RESERVE_ID = 2i32;
7703 pub const StorageReserveIdUpdateScratch: STORAGE_RESERVE_ID = 3i32;
7704 pub const StorageReserveIdMax: STORAGE_RESERVE_ID = 4i32;
7705 pub type STORAGE_RPMB_COMMAND_TYPE = i32;
7706 pub const StorRpmbProgramAuthKey: STORAGE_RPMB_COMMAND_TYPE = 1i32;
7707 pub const StorRpmbQueryWriteCounter: STORAGE_RPMB_COMMAND_TYPE = 2i32;
7708 pub const StorRpmbAuthenticatedWrite: STORAGE_RPMB_COMMAND_TYPE = 3i32;
7709 pub const StorRpmbAuthenticatedRead: STORAGE_RPMB_COMMAND_TYPE = 4i32;
7710 pub const StorRpmbReadResultRequest: STORAGE_RPMB_COMMAND_TYPE = 5i32;
7711 pub const StorRpmbAuthenticatedDeviceConfigWrite: STORAGE_RPMB_COMMAND_TYPE = 6i32;
7712 pub const StorRpmbAuthenticatedDeviceConfigRead: STORAGE_RPMB_COMMAND_TYPE = 7i32;
7713 #[repr(C)]
7714 pub struct STORAGE_RPMB_DATA_FRAME {
7715     pub Stuff: [u8; 196],
7716     pub KeyOrMAC: [u8; 32],
7717     pub Data: [u8; 256],
7718     pub Nonce: [u8; 16],
7719     pub WriteCounter: [u8; 4],
7720     pub Address: [u8; 2],
7721     pub BlockCount: [u8; 2],
7722     pub OperationResult: [u8; 2],
7723     pub RequestOrResponseType: [u8; 2],
7724 }
7725 impl ::core::marker::Copy for STORAGE_RPMB_DATA_FRAME {}
7726 impl ::core::clone::Clone for STORAGE_RPMB_DATA_FRAME {
7727     fn clone(&self) -> Self {
7728         *self
7729     }
7730 }
7731 #[repr(C)]
7732 pub struct STORAGE_RPMB_DESCRIPTOR {
7733     pub Version: u32,
7734     pub Size: u32,
7735     pub SizeInBytes: u32,
7736     pub MaxReliableWriteSizeInBytes: u32,
7737     pub FrameFormat: STORAGE_RPMB_FRAME_TYPE,
7738 }
7739 impl ::core::marker::Copy for STORAGE_RPMB_DESCRIPTOR {}
7740 impl ::core::clone::Clone for STORAGE_RPMB_DESCRIPTOR {
7741     fn clone(&self) -> Self {
7742         *self
7743     }
7744 }
7745 pub const STORAGE_RPMB_DESCRIPTOR_VERSION_1: u32 = 1u32;
7746 pub type STORAGE_RPMB_FRAME_TYPE = i32;
7747 pub const StorageRpmbFrameTypeUnknown: STORAGE_RPMB_FRAME_TYPE = 0i32;
7748 pub const StorageRpmbFrameTypeStandard: STORAGE_RPMB_FRAME_TYPE = 1i32;
7749 pub const StorageRpmbFrameTypeMax: STORAGE_RPMB_FRAME_TYPE = 2i32;
7750 pub const STORAGE_RPMB_MINIMUM_RELIABLE_WRITE_SIZE: u32 = 512u32;
7751 pub type STORAGE_SANITIZE_METHOD = i32;
7752 pub const StorageSanitizeMethodDefault: STORAGE_SANITIZE_METHOD = 0i32;
7753 pub const StorageSanitizeMethodBlockErase: STORAGE_SANITIZE_METHOD = 1i32;
7754 pub const StorageSanitizeMethodCryptoErase: STORAGE_SANITIZE_METHOD = 2i32;
7755 pub type STORAGE_SET_TYPE = i32;
7756 pub const PropertyStandardSet: STORAGE_SET_TYPE = 0i32;
7757 pub const PropertyExistsSet: STORAGE_SET_TYPE = 1i32;
7758 pub const PropertySetMaxDefined: STORAGE_SET_TYPE = 2i32;
7759 #[repr(C)]
7760 pub union STORAGE_SPEC_VERSION {
7761     pub Anonymous: STORAGE_SPEC_VERSION_0,
7762     pub AsUlong: u32,
7763 }
7764 impl ::core::marker::Copy for STORAGE_SPEC_VERSION {}
7765 impl ::core::clone::Clone for STORAGE_SPEC_VERSION {
7766     fn clone(&self) -> Self {
7767         *self
7768     }
7769 }
7770 #[repr(C)]
7771 pub struct STORAGE_SPEC_VERSION_0 {
7772     pub MinorVersion: STORAGE_SPEC_VERSION_0_0,
7773     pub MajorVersion: u16,
7774 }
7775 impl ::core::marker::Copy for STORAGE_SPEC_VERSION_0 {}
7776 impl ::core::clone::Clone for STORAGE_SPEC_VERSION_0 {
7777     fn clone(&self) -> Self {
7778         *self
7779     }
7780 }
7781 #[repr(C)]
7782 pub union STORAGE_SPEC_VERSION_0_0 {
7783     pub Anonymous: STORAGE_SPEC_VERSION_0_0_0,
7784     pub AsUshort: u16,
7785 }
7786 impl ::core::marker::Copy for STORAGE_SPEC_VERSION_0_0 {}
7787 impl ::core::clone::Clone for STORAGE_SPEC_VERSION_0_0 {
7788     fn clone(&self) -> Self {
7789         *self
7790     }
7791 }
7792 #[repr(C)]
7793 pub struct STORAGE_SPEC_VERSION_0_0_0 {
7794     pub SubMinor: u8,
7795     pub Minor: u8,
7796 }
7797 impl ::core::marker::Copy for STORAGE_SPEC_VERSION_0_0_0 {}
7798 impl ::core::clone::Clone for STORAGE_SPEC_VERSION_0_0_0 {
7799     fn clone(&self) -> Self {
7800         *self
7801     }
7802 }
7803 pub const STORAGE_SUPPORTED_FEATURES_BYPASS_IO: u32 = 1u32;
7804 pub const STORAGE_SUPPORTED_FEATURES_MASK: u32 = 1u32;
7805 #[repr(C)]
7806 #[cfg(feature = "Win32_Foundation")]
7807 pub struct STORAGE_TEMPERATURE_DATA_DESCRIPTOR {
7808     pub Version: u32,
7809     pub Size: u32,
7810     pub CriticalTemperature: i16,
7811     pub WarningTemperature: i16,
7812     pub InfoCount: u16,
7813     pub Reserved0: [u8; 2],
7814     pub Reserved1: [u32; 2],
7815     pub TemperatureInfo: [STORAGE_TEMPERATURE_INFO; 1],
7816 }
7817 #[cfg(feature = "Win32_Foundation")]
7818 impl ::core::marker::Copy for STORAGE_TEMPERATURE_DATA_DESCRIPTOR {}
7819 #[cfg(feature = "Win32_Foundation")]
7820 impl ::core::clone::Clone for STORAGE_TEMPERATURE_DATA_DESCRIPTOR {
7821     fn clone(&self) -> Self {
7822         *self
7823     }
7824 }
7825 #[repr(C)]
7826 #[cfg(feature = "Win32_Foundation")]
7827 pub struct STORAGE_TEMPERATURE_INFO {
7828     pub Index: u16,
7829     pub Temperature: i16,
7830     pub OverThreshold: i16,
7831     pub UnderThreshold: i16,
7832     pub OverThresholdChangable: super::super::Foundation::BOOLEAN,
7833     pub UnderThresholdChangable: super::super::Foundation::BOOLEAN,
7834     pub EventGenerated: super::super::Foundation::BOOLEAN,
7835     pub Reserved0: u8,
7836     pub Reserved1: u32,
7837 }
7838 #[cfg(feature = "Win32_Foundation")]
7839 impl ::core::marker::Copy for STORAGE_TEMPERATURE_INFO {}
7840 #[cfg(feature = "Win32_Foundation")]
7841 impl ::core::clone::Clone for STORAGE_TEMPERATURE_INFO {
7842     fn clone(&self) -> Self {
7843         *self
7844     }
7845 }
7846 #[repr(C)]
7847 #[cfg(feature = "Win32_Foundation")]
7848 pub struct STORAGE_TEMPERATURE_THRESHOLD {
7849     pub Version: u32,
7850     pub Size: u32,
7851     pub Flags: u16,
7852     pub Index: u16,
7853     pub Threshold: i16,
7854     pub OverThreshold: super::super::Foundation::BOOLEAN,
7855     pub Reserved: u8,
7856 }
7857 #[cfg(feature = "Win32_Foundation")]
7858 impl ::core::marker::Copy for STORAGE_TEMPERATURE_THRESHOLD {}
7859 #[cfg(feature = "Win32_Foundation")]
7860 impl ::core::clone::Clone for STORAGE_TEMPERATURE_THRESHOLD {
7861     fn clone(&self) -> Self {
7862         *self
7863     }
7864 }
7865 pub const STORAGE_TEMPERATURE_THRESHOLD_FLAG_ADAPTER_REQUEST: u32 = 1u32;
7866 pub const STORAGE_TEMPERATURE_VALUE_NOT_REPORTED: u32 = 32768u32;
7867 #[repr(C)]
7868 pub struct STORAGE_TIER {
7869     pub Id: ::windows_sys::core::GUID,
7870     pub Name: [u16; 256],
7871     pub Description: [u16; 256],
7872     pub Flags: u64,
7873     pub ProvisionedCapacity: u64,
7874     pub MediaType: STORAGE_TIER_MEDIA_TYPE,
7875     pub Class: STORAGE_TIER_CLASS,
7876 }
7877 impl ::core::marker::Copy for STORAGE_TIER {}
7878 impl ::core::clone::Clone for STORAGE_TIER {
7879     fn clone(&self) -> Self {
7880         *self
7881     }
7882 }
7883 pub type STORAGE_TIER_CLASS = i32;
7884 pub const StorageTierClassUnspecified: STORAGE_TIER_CLASS = 0i32;
7885 pub const StorageTierClassCapacity: STORAGE_TIER_CLASS = 1i32;
7886 pub const StorageTierClassPerformance: STORAGE_TIER_CLASS = 2i32;
7887 pub const StorageTierClassMax: STORAGE_TIER_CLASS = 3i32;
7888 pub const STORAGE_TIER_DESCRIPTION_LENGTH: u32 = 512u32;
7889 pub const STORAGE_TIER_FLAG_NO_SEEK_PENALTY: u32 = 131072u32;
7890 pub const STORAGE_TIER_FLAG_PARITY: u32 = 8388608u32;
7891 pub const STORAGE_TIER_FLAG_READ_CACHE: u32 = 4194304u32;
7892 pub const STORAGE_TIER_FLAG_SMR: u32 = 16777216u32;
7893 pub const STORAGE_TIER_FLAG_WRITE_BACK_CACHE: u32 = 2097152u32;
7894 pub type STORAGE_TIER_MEDIA_TYPE = i32;
7895 pub const StorageTierMediaTypeUnspecified: STORAGE_TIER_MEDIA_TYPE = 0i32;
7896 pub const StorageTierMediaTypeDisk: STORAGE_TIER_MEDIA_TYPE = 1i32;
7897 pub const StorageTierMediaTypeSsd: STORAGE_TIER_MEDIA_TYPE = 2i32;
7898 pub const StorageTierMediaTypeScm: STORAGE_TIER_MEDIA_TYPE = 4i32;
7899 pub const StorageTierMediaTypeMax: STORAGE_TIER_MEDIA_TYPE = 5i32;
7900 pub const STORAGE_TIER_NAME_LENGTH: u32 = 256u32;
7901 #[repr(C)]
7902 pub struct STORAGE_TIER_REGION {
7903     pub TierId: ::windows_sys::core::GUID,
7904     pub Offset: u64,
7905     pub Length: u64,
7906 }
7907 impl ::core::marker::Copy for STORAGE_TIER_REGION {}
7908 impl ::core::clone::Clone for STORAGE_TIER_REGION {
7909     fn clone(&self) -> Self {
7910         *self
7911     }
7912 }
7913 #[repr(C)]
7914 #[cfg(feature = "Win32_Foundation")]
7915 pub struct STORAGE_WRITE_CACHE_PROPERTY {
7916     pub Version: u32,
7917     pub Size: u32,
7918     pub WriteCacheType: WRITE_CACHE_TYPE,
7919     pub WriteCacheEnabled: WRITE_CACHE_ENABLE,
7920     pub WriteCacheChangeable: WRITE_CACHE_CHANGE,
7921     pub WriteThroughSupported: WRITE_THROUGH,
7922     pub FlushCacheSupported: super::super::Foundation::BOOLEAN,
7923     pub UserDefinedPowerProtection: super::super::Foundation::BOOLEAN,
7924     pub NVCacheEnabled: super::super::Foundation::BOOLEAN,
7925 }
7926 #[cfg(feature = "Win32_Foundation")]
7927 impl ::core::marker::Copy for STORAGE_WRITE_CACHE_PROPERTY {}
7928 #[cfg(feature = "Win32_Foundation")]
7929 impl ::core::clone::Clone for STORAGE_WRITE_CACHE_PROPERTY {
7930     fn clone(&self) -> Self {
7931         *self
7932     }
7933 }
7934 #[repr(C)]
7935 #[cfg(feature = "Win32_Foundation")]
7936 pub struct STORAGE_ZONED_DEVICE_DESCRIPTOR {
7937     pub Version: u32,
7938     pub Size: u32,
7939     pub DeviceType: STORAGE_ZONED_DEVICE_TYPES,
7940     pub ZoneCount: u32,
7941     pub ZoneAttributes: STORAGE_ZONED_DEVICE_DESCRIPTOR_0,
7942     pub ZoneGroupCount: u32,
7943     pub ZoneGroup: [STORAGE_ZONE_GROUP; 1],
7944 }
7945 #[cfg(feature = "Win32_Foundation")]
7946 impl ::core::marker::Copy for STORAGE_ZONED_DEVICE_DESCRIPTOR {}
7947 #[cfg(feature = "Win32_Foundation")]
7948 impl ::core::clone::Clone for STORAGE_ZONED_DEVICE_DESCRIPTOR {
7949     fn clone(&self) -> Self {
7950         *self
7951     }
7952 }
7953 #[repr(C)]
7954 #[cfg(feature = "Win32_Foundation")]
7955 pub union STORAGE_ZONED_DEVICE_DESCRIPTOR_0 {
7956     pub SequentialRequiredZone: STORAGE_ZONED_DEVICE_DESCRIPTOR_0_1,
7957     pub SequentialPreferredZone: STORAGE_ZONED_DEVICE_DESCRIPTOR_0_0,
7958 }
7959 #[cfg(feature = "Win32_Foundation")]
7960 impl ::core::marker::Copy for STORAGE_ZONED_DEVICE_DESCRIPTOR_0 {}
7961 #[cfg(feature = "Win32_Foundation")]
7962 impl ::core::clone::Clone for STORAGE_ZONED_DEVICE_DESCRIPTOR_0 {
7963     fn clone(&self) -> Self {
7964         *self
7965     }
7966 }
7967 #[repr(C)]
7968 #[cfg(feature = "Win32_Foundation")]
7969 pub struct STORAGE_ZONED_DEVICE_DESCRIPTOR_0_0 {
7970     pub OptimalOpenZoneCount: u32,
7971     pub Reserved: u32,
7972 }
7973 #[cfg(feature = "Win32_Foundation")]
7974 impl ::core::marker::Copy for STORAGE_ZONED_DEVICE_DESCRIPTOR_0_0 {}
7975 #[cfg(feature = "Win32_Foundation")]
7976 impl ::core::clone::Clone for STORAGE_ZONED_DEVICE_DESCRIPTOR_0_0 {
7977     fn clone(&self) -> Self {
7978         *self
7979     }
7980 }
7981 #[repr(C)]
7982 #[cfg(feature = "Win32_Foundation")]
7983 pub struct STORAGE_ZONED_DEVICE_DESCRIPTOR_0_1 {
7984     pub MaxOpenZoneCount: u32,
7985     pub UnrestrictedRead: super::super::Foundation::BOOLEAN,
7986     pub Reserved: [u8; 3],
7987 }
7988 #[cfg(feature = "Win32_Foundation")]
7989 impl ::core::marker::Copy for STORAGE_ZONED_DEVICE_DESCRIPTOR_0_1 {}
7990 #[cfg(feature = "Win32_Foundation")]
7991 impl ::core::clone::Clone for STORAGE_ZONED_DEVICE_DESCRIPTOR_0_1 {
7992     fn clone(&self) -> Self {
7993         *self
7994     }
7995 }
7996 pub type STORAGE_ZONED_DEVICE_TYPES = i32;
7997 pub const ZonedDeviceTypeUnknown: STORAGE_ZONED_DEVICE_TYPES = 0i32;
7998 pub const ZonedDeviceTypeHostManaged: STORAGE_ZONED_DEVICE_TYPES = 1i32;
7999 pub const ZonedDeviceTypeHostAware: STORAGE_ZONED_DEVICE_TYPES = 2i32;
8000 pub const ZonedDeviceTypeDeviceManaged: STORAGE_ZONED_DEVICE_TYPES = 3i32;
8001 pub type STORAGE_ZONES_ATTRIBUTES = i32;
8002 pub const ZonesAttributeTypeAndLengthMayDifferent: STORAGE_ZONES_ATTRIBUTES = 0i32;
8003 pub const ZonesAttributeTypeSameLengthSame: STORAGE_ZONES_ATTRIBUTES = 1i32;
8004 pub const ZonesAttributeTypeSameLastZoneLengthDifferent: STORAGE_ZONES_ATTRIBUTES = 2i32;
8005 pub const ZonesAttributeTypeMayDifferentLengthSame: STORAGE_ZONES_ATTRIBUTES = 3i32;
8006 pub type STORAGE_ZONE_CONDITION = i32;
8007 pub const ZoneConditionConventional: STORAGE_ZONE_CONDITION = 0i32;
8008 pub const ZoneConditionEmpty: STORAGE_ZONE_CONDITION = 1i32;
8009 pub const ZoneConditionImplicitlyOpened: STORAGE_ZONE_CONDITION = 2i32;
8010 pub const ZoneConditionExplicitlyOpened: STORAGE_ZONE_CONDITION = 3i32;
8011 pub const ZoneConditionClosed: STORAGE_ZONE_CONDITION = 4i32;
8012 pub const ZoneConditionReadOnly: STORAGE_ZONE_CONDITION = 13i32;
8013 pub const ZoneConditionFull: STORAGE_ZONE_CONDITION = 14i32;
8014 pub const ZoneConditionOffline: STORAGE_ZONE_CONDITION = 15i32;
8015 #[repr(C)]
8016 #[cfg(feature = "Win32_Foundation")]
8017 pub struct STORAGE_ZONE_DESCRIPTOR {
8018     pub Size: u32,
8019     pub ZoneType: STORAGE_ZONE_TYPES,
8020     pub ZoneCondition: STORAGE_ZONE_CONDITION,
8021     pub ResetWritePointerRecommend: super::super::Foundation::BOOLEAN,
8022     pub Reserved0: [u8; 3],
8023     pub ZoneSize: u64,
8024     pub WritePointerOffset: u64,
8025 }
8026 #[cfg(feature = "Win32_Foundation")]
8027 impl ::core::marker::Copy for STORAGE_ZONE_DESCRIPTOR {}
8028 #[cfg(feature = "Win32_Foundation")]
8029 impl ::core::clone::Clone for STORAGE_ZONE_DESCRIPTOR {
8030     fn clone(&self) -> Self {
8031         *self
8032     }
8033 }
8034 #[repr(C)]
8035 pub struct STORAGE_ZONE_GROUP {
8036     pub ZoneCount: u32,
8037     pub ZoneType: STORAGE_ZONE_TYPES,
8038     pub ZoneSize: u64,
8039 }
8040 impl ::core::marker::Copy for STORAGE_ZONE_GROUP {}
8041 impl ::core::clone::Clone for STORAGE_ZONE_GROUP {
8042     fn clone(&self) -> Self {
8043         *self
8044     }
8045 }
8046 pub type STORAGE_ZONE_TYPES = i32;
8047 pub const ZoneTypeUnknown: STORAGE_ZONE_TYPES = 0i32;
8048 pub const ZoneTypeConventional: STORAGE_ZONE_TYPES = 1i32;
8049 pub const ZoneTypeSequentialWriteRequired: STORAGE_ZONE_TYPES = 2i32;
8050 pub const ZoneTypeSequentialWritePreferred: STORAGE_ZONE_TYPES = 3i32;
8051 pub const ZoneTypeMax: STORAGE_ZONE_TYPES = 4i32;
8052 pub const STORATTRIBUTE_MANAGEMENT_STATE: u32 = 1u32;
8053 pub const STORATTRIBUTE_NONE: u32 = 0u32;
8054 pub const STREAMS_ASSOCIATE_ID_CLEAR: u32 = 1u32;
8055 #[repr(C)]
8056 pub struct STREAMS_ASSOCIATE_ID_INPUT_BUFFER {
8057     pub Flags: u32,
8058     pub StreamId: u32,
8059 }
8060 impl ::core::marker::Copy for STREAMS_ASSOCIATE_ID_INPUT_BUFFER {}
8061 impl ::core::clone::Clone for STREAMS_ASSOCIATE_ID_INPUT_BUFFER {
8062     fn clone(&self) -> Self {
8063         *self
8064     }
8065 }
8066 pub const STREAMS_ASSOCIATE_ID_SET: u32 = 2u32;
8067 pub const STREAMS_INVALID_ID: u32 = 0u32;
8068 pub const STREAMS_MAX_ID: u32 = 65535u32;
8069 #[repr(C)]
8070 pub struct STREAMS_QUERY_ID_OUTPUT_BUFFER {
8071     pub StreamId: u32,
8072 }
8073 impl ::core::marker::Copy for STREAMS_QUERY_ID_OUTPUT_BUFFER {}
8074 impl ::core::clone::Clone for STREAMS_QUERY_ID_OUTPUT_BUFFER {
8075     fn clone(&self) -> Self {
8076         *self
8077     }
8078 }
8079 #[repr(C)]
8080 pub struct STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER {
8081     pub OptimalWriteSize: u32,
8082     pub StreamGranularitySize: u32,
8083     pub StreamIdMin: u32,
8084     pub StreamIdMax: u32,
8085 }
8086 impl ::core::marker::Copy for STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER {}
8087 impl ::core::clone::Clone for STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER {
8088     fn clone(&self) -> Self {
8089         *self
8090     }
8091 }
8092 pub const STREAM_CLEAR_ENCRYPTION: u32 = 4u32;
8093 #[repr(C)]
8094 pub struct STREAM_EXTENT_ENTRY {
8095     pub Flags: u32,
8096     pub ExtentInformation: STREAM_EXTENT_ENTRY_0,
8097 }
8098 impl ::core::marker::Copy for STREAM_EXTENT_ENTRY {}
8099 impl ::core::clone::Clone for STREAM_EXTENT_ENTRY {
8100     fn clone(&self) -> Self {
8101         *self
8102     }
8103 }
8104 #[repr(C)]
8105 pub union STREAM_EXTENT_ENTRY_0 {
8106     pub RetrievalPointers: RETRIEVAL_POINTERS_BUFFER,
8107 }
8108 impl ::core::marker::Copy for STREAM_EXTENT_ENTRY_0 {}
8109 impl ::core::clone::Clone for STREAM_EXTENT_ENTRY_0 {
8110     fn clone(&self) -> Self {
8111         *self
8112     }
8113 }
8114 pub const STREAM_EXTENT_ENTRY_ALL_EXTENTS: u32 = 2u32;
8115 pub const STREAM_EXTENT_ENTRY_AS_RETRIEVAL_POINTERS: u32 = 1u32;
8116 #[repr(C)]
8117 pub struct STREAM_INFORMATION_ENTRY {
8118     pub Version: u32,
8119     pub Flags: u32,
8120     pub StreamInformation: STREAM_INFORMATION_ENTRY_0,
8121 }
8122 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY {}
8123 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY {
8124     fn clone(&self) -> Self {
8125         *self
8126     }
8127 }
8128 #[repr(C)]
8129 pub union STREAM_INFORMATION_ENTRY_0 {
8130     pub DesiredStorageClass: STREAM_INFORMATION_ENTRY_0_1,
8131     pub DataStream: STREAM_INFORMATION_ENTRY_0_0,
8132     pub Reparse: STREAM_INFORMATION_ENTRY_0_3,
8133     pub Ea: STREAM_INFORMATION_ENTRY_0_2,
8134 }
8135 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY_0 {}
8136 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY_0 {
8137     fn clone(&self) -> Self {
8138         *self
8139     }
8140 }
8141 #[repr(C)]
8142 pub struct STREAM_INFORMATION_ENTRY_0_0 {
8143     pub Length: u16,
8144     pub Flags: u16,
8145     pub Reserved: u32,
8146     pub Vdl: u64,
8147 }
8148 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY_0_0 {}
8149 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY_0_0 {
8150     fn clone(&self) -> Self {
8151         *self
8152     }
8153 }
8154 #[repr(C)]
8155 pub struct STREAM_INFORMATION_ENTRY_0_1 {
8156     pub Class: FILE_STORAGE_TIER_CLASS,
8157     pub Flags: u32,
8158 }
8159 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY_0_1 {}
8160 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY_0_1 {
8161     fn clone(&self) -> Self {
8162         *self
8163     }
8164 }
8165 #[repr(C)]
8166 pub struct STREAM_INFORMATION_ENTRY_0_2 {
8167     pub Length: u16,
8168     pub Flags: u16,
8169     pub EaSize: u32,
8170     pub EaInformationOffset: u32,
8171 }
8172 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY_0_2 {}
8173 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY_0_2 {
8174     fn clone(&self) -> Self {
8175         *self
8176     }
8177 }
8178 #[repr(C)]
8179 pub struct STREAM_INFORMATION_ENTRY_0_3 {
8180     pub Length: u16,
8181     pub Flags: u16,
8182     pub ReparseDataSize: u32,
8183     pub ReparseDataOffset: u32,
8184 }
8185 impl ::core::marker::Copy for STREAM_INFORMATION_ENTRY_0_3 {}
8186 impl ::core::clone::Clone for STREAM_INFORMATION_ENTRY_0_3 {
8187     fn clone(&self) -> Self {
8188         *self
8189     }
8190 }
8191 #[repr(C)]
8192 pub struct STREAM_LAYOUT_ENTRY {
8193     pub Version: u32,
8194     pub NextStreamOffset: u32,
8195     pub Flags: u32,
8196     pub ExtentInformationOffset: u32,
8197     pub AllocationSize: i64,
8198     pub EndOfFile: i64,
8199     pub StreamInformationOffset: u32,
8200     pub AttributeTypeCode: u32,
8201     pub AttributeFlags: u32,
8202     pub StreamIdentifierLength: u32,
8203     pub StreamIdentifier: [u16; 1],
8204 }
8205 impl ::core::marker::Copy for STREAM_LAYOUT_ENTRY {}
8206 impl ::core::clone::Clone for STREAM_LAYOUT_ENTRY {
8207     fn clone(&self) -> Self {
8208         *self
8209     }
8210 }
8211 pub const STREAM_LAYOUT_ENTRY_HAS_INFORMATION: u32 = 16u32;
8212 pub const STREAM_LAYOUT_ENTRY_IMMOVABLE: u32 = 1u32;
8213 pub const STREAM_LAYOUT_ENTRY_NO_CLUSTERS_ALLOCATED: u32 = 8u32;
8214 pub const STREAM_LAYOUT_ENTRY_PINNED: u32 = 2u32;
8215 pub const STREAM_LAYOUT_ENTRY_RESIDENT: u32 = 4u32;
8216 pub const STREAM_SET_ENCRYPTION: u32 = 3u32;
8217 #[repr(C)]
8218 pub struct TAPE_GET_STATISTICS {
8219     pub Operation: u32,
8220 }
8221 impl ::core::marker::Copy for TAPE_GET_STATISTICS {}
8222 impl ::core::clone::Clone for TAPE_GET_STATISTICS {
8223     fn clone(&self) -> Self {
8224         *self
8225     }
8226 }
8227 pub const TAPE_RESET_STATISTICS: i32 = 2i32;
8228 pub const TAPE_RETURN_ENV_INFO: i32 = 1i32;
8229 pub const TAPE_RETURN_STATISTICS: i32 = 0i32;
8230 #[repr(C)]
8231 pub struct TAPE_STATISTICS {
8232     pub Version: u32,
8233     pub Flags: u32,
8234     pub RecoveredWrites: i64,
8235     pub UnrecoveredWrites: i64,
8236     pub RecoveredReads: i64,
8237     pub UnrecoveredReads: i64,
8238     pub CompressionRatioReads: u8,
8239     pub CompressionRatioWrites: u8,
8240 }
8241 impl ::core::marker::Copy for TAPE_STATISTICS {}
8242 impl ::core::clone::Clone for TAPE_STATISTICS {
8243     fn clone(&self) -> Self {
8244         *self
8245     }
8246 }
8247 pub const TC_DEVICEDUMP_SUBSECTION_DESC_LENGTH: u32 = 16u32;
8248 pub const TC_PUBLIC_DEVICEDUMP_CONTENT_GPLOG: u32 = 2u32;
8249 pub const TC_PUBLIC_DEVICEDUMP_CONTENT_GPLOG_MAX: u32 = 16u32;
8250 pub const TC_PUBLIC_DEVICEDUMP_CONTENT_SMART: u32 = 1u32;
8251 pub const TELEMETRY_COMMAND_SIZE: u32 = 16u32;
8252 #[repr(C)]
8253 pub struct TXFS_CREATE_MINIVERSION_INFO {
8254     pub StructureVersion: u16,
8255     pub StructureLength: u16,
8256     pub BaseVersion: u32,
8257     pub MiniVersion: u16,
8258 }
8259 impl ::core::marker::Copy for TXFS_CREATE_MINIVERSION_INFO {}
8260 impl ::core::clone::Clone for TXFS_CREATE_MINIVERSION_INFO {
8261     fn clone(&self) -> Self {
8262         *self
8263     }
8264 }
8265 #[repr(C)]
8266 pub struct TXFS_GET_METADATA_INFO_OUT {
8267     pub TxfFileId: TXFS_GET_METADATA_INFO_OUT_0,
8268     pub LockingTransaction: ::windows_sys::core::GUID,
8269     pub LastLsn: u64,
8270     pub TransactionState: u32,
8271 }
8272 impl ::core::marker::Copy for TXFS_GET_METADATA_INFO_OUT {}
8273 impl ::core::clone::Clone for TXFS_GET_METADATA_INFO_OUT {
8274     fn clone(&self) -> Self {
8275         *self
8276     }
8277 }
8278 #[repr(C)]
8279 pub struct TXFS_GET_METADATA_INFO_OUT_0 {
8280     pub LowPart: i64,
8281     pub HighPart: i64,
8282 }
8283 impl ::core::marker::Copy for TXFS_GET_METADATA_INFO_OUT_0 {}
8284 impl ::core::clone::Clone for TXFS_GET_METADATA_INFO_OUT_0 {
8285     fn clone(&self) -> Self {
8286         *self
8287     }
8288 }
8289 #[repr(C)]
8290 pub struct TXFS_GET_TRANSACTED_VERSION {
8291     pub ThisBaseVersion: u32,
8292     pub LatestVersion: u32,
8293     pub ThisMiniVersion: u16,
8294     pub FirstMiniVersion: u16,
8295     pub LatestMiniVersion: u16,
8296 }
8297 impl ::core::marker::Copy for TXFS_GET_TRANSACTED_VERSION {}
8298 impl ::core::clone::Clone for TXFS_GET_TRANSACTED_VERSION {
8299     fn clone(&self) -> Self {
8300         *self
8301     }
8302 }
8303 #[repr(C)]
8304 pub struct TXFS_LIST_TRANSACTIONS {
8305     pub NumberOfTransactions: u64,
8306     pub BufferSizeRequired: u64,
8307 }
8308 impl ::core::marker::Copy for TXFS_LIST_TRANSACTIONS {}
8309 impl ::core::clone::Clone for TXFS_LIST_TRANSACTIONS {
8310     fn clone(&self) -> Self {
8311         *self
8312     }
8313 }
8314 #[repr(C)]
8315 pub struct TXFS_LIST_TRANSACTIONS_ENTRY {
8316     pub TransactionId: ::windows_sys::core::GUID,
8317     pub TransactionState: u32,
8318     pub Reserved1: u32,
8319     pub Reserved2: u32,
8320     pub Reserved3: i64,
8321 }
8322 impl ::core::marker::Copy for TXFS_LIST_TRANSACTIONS_ENTRY {}
8323 impl ::core::clone::Clone for TXFS_LIST_TRANSACTIONS_ENTRY {
8324     fn clone(&self) -> Self {
8325         *self
8326     }
8327 }
8328 #[repr(C)]
8329 pub struct TXFS_LIST_TRANSACTION_LOCKED_FILES {
8330     pub KtmTransaction: ::windows_sys::core::GUID,
8331     pub NumberOfFiles: u64,
8332     pub BufferSizeRequired: u64,
8333     pub Offset: u64,
8334 }
8335 impl ::core::marker::Copy for TXFS_LIST_TRANSACTION_LOCKED_FILES {}
8336 impl ::core::clone::Clone for TXFS_LIST_TRANSACTION_LOCKED_FILES {
8337     fn clone(&self) -> Self {
8338         *self
8339     }
8340 }
8341 #[repr(C)]
8342 pub struct TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY {
8343     pub Offset: u64,
8344     pub NameFlags: u32,
8345     pub FileId: i64,
8346     pub Reserved1: u32,
8347     pub Reserved2: u32,
8348     pub Reserved3: i64,
8349     pub FileName: [u16; 1],
8350 }
8351 impl ::core::marker::Copy for TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY {}
8352 impl ::core::clone::Clone for TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY {
8353     fn clone(&self) -> Self {
8354         *self
8355     }
8356 }
8357 pub const TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY_FLAG_CREATED: u32 = 1u32;
8358 pub const TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY_FLAG_DELETED: u32 = 2u32;
8359 pub const TXFS_LOGGING_MODE_FULL: u32 = 2u32;
8360 pub const TXFS_LOGGING_MODE_SIMPLE: u32 = 1u32;
8361 #[repr(C)]
8362 pub struct TXFS_MODIFY_RM {
8363     pub Flags: TXFS_RMF_LAGS,
8364     pub LogContainerCountMax: u32,
8365     pub LogContainerCountMin: u32,
8366     pub LogContainerCount: u32,
8367     pub LogGrowthIncrement: u32,
8368     pub LogAutoShrinkPercentage: u32,
8369     pub Reserved: u64,
8370     pub LoggingMode: u16,
8371 }
8372 impl ::core::marker::Copy for TXFS_MODIFY_RM {}
8373 impl ::core::clone::Clone for TXFS_MODIFY_RM {
8374     fn clone(&self) -> Self {
8375         *self
8376     }
8377 }
8378 #[repr(C)]
8379 pub struct TXFS_QUERY_RM_INFORMATION {
8380     pub BytesRequired: u32,
8381     pub TailLsn: u64,
8382     pub CurrentLsn: u64,
8383     pub ArchiveTailLsn: u64,
8384     pub LogContainerSize: u64,
8385     pub HighestVirtualClock: i64,
8386     pub LogContainerCount: u32,
8387     pub LogContainerCountMax: u32,
8388     pub LogContainerCountMin: u32,
8389     pub LogGrowthIncrement: u32,
8390     pub LogAutoShrinkPercentage: u32,
8391     pub Flags: TXFS_RMF_LAGS,
8392     pub LoggingMode: u16,
8393     pub Reserved: u16,
8394     pub RmState: u32,
8395     pub LogCapacity: u64,
8396     pub LogFree: u64,
8397     pub TopsSize: u64,
8398     pub TopsUsed: u64,
8399     pub TransactionCount: u64,
8400     pub OnePCCount: u64,
8401     pub TwoPCCount: u64,
8402     pub NumberLogFileFull: u64,
8403     pub OldestTransactionAge: u64,
8404     pub RMName: ::windows_sys::core::GUID,
8405     pub TmLogPathOffset: u32,
8406 }
8407 impl ::core::marker::Copy for TXFS_QUERY_RM_INFORMATION {}
8408 impl ::core::clone::Clone for TXFS_QUERY_RM_INFORMATION {
8409     fn clone(&self) -> Self {
8410         *self
8411     }
8412 }
8413 #[repr(C)]
8414 pub struct TXFS_READ_BACKUP_INFORMATION_OUT {
8415     pub Anonymous: TXFS_READ_BACKUP_INFORMATION_OUT_0,
8416 }
8417 impl ::core::marker::Copy for TXFS_READ_BACKUP_INFORMATION_OUT {}
8418 impl ::core::clone::Clone for TXFS_READ_BACKUP_INFORMATION_OUT {
8419     fn clone(&self) -> Self {
8420         *self
8421     }
8422 }
8423 #[repr(C)]
8424 pub union TXFS_READ_BACKUP_INFORMATION_OUT_0 {
8425     pub BufferLength: u32,
8426     pub Buffer: [u8; 1],
8427 }
8428 impl ::core::marker::Copy for TXFS_READ_BACKUP_INFORMATION_OUT_0 {}
8429 impl ::core::clone::Clone for TXFS_READ_BACKUP_INFORMATION_OUT_0 {
8430     fn clone(&self) -> Self {
8431         *self
8432     }
8433 }
8434 pub type TXFS_RMF_LAGS = u32;
8435 pub const TXFS_RM_FLAG_LOGGING_MODE: TXFS_RMF_LAGS = 1u32;
8436 pub const TXFS_RM_FLAG_RENAME_RM: TXFS_RMF_LAGS = 2u32;
8437 pub const TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MAX: TXFS_RMF_LAGS = 4u32;
8438 pub const TXFS_RM_FLAG_LOG_CONTAINER_COUNT_MIN: TXFS_RMF_LAGS = 8u32;
8439 pub const TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS: TXFS_RMF_LAGS = 16u32;
8440 pub const TXFS_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT: TXFS_RMF_LAGS = 32u32;
8441 pub const TXFS_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE: TXFS_RMF_LAGS = 64u32;
8442 pub const TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX: TXFS_RMF_LAGS = 128u32;
8443 pub const TXFS_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN: TXFS_RMF_LAGS = 256u32;
8444 pub const TXFS_RM_FLAG_GROW_LOG: TXFS_RMF_LAGS = 1024u32;
8445 pub const TXFS_RM_FLAG_SHRINK_LOG: TXFS_RMF_LAGS = 2048u32;
8446 pub const TXFS_RM_FLAG_ENFORCE_MINIMUM_SIZE: TXFS_RMF_LAGS = 4096u32;
8447 pub const TXFS_RM_FLAG_PRESERVE_CHANGES: TXFS_RMF_LAGS = 8192u32;
8448 pub const TXFS_RM_FLAG_RESET_RM_AT_NEXT_START: TXFS_RMF_LAGS = 16384u32;
8449 pub const TXFS_RM_FLAG_DO_NOT_RESET_RM_AT_NEXT_START: TXFS_RMF_LAGS = 32768u32;
8450 pub const TXFS_RM_FLAG_PREFER_CONSISTENCY: TXFS_RMF_LAGS = 65536u32;
8451 pub const TXFS_RM_FLAG_PREFER_AVAILABILITY: TXFS_RMF_LAGS = 131072u32;
8452 pub const TXFS_RM_STATE_ACTIVE: u32 = 2u32;
8453 pub const TXFS_RM_STATE_NOT_STARTED: u32 = 0u32;
8454 pub const TXFS_RM_STATE_SHUTTING_DOWN: u32 = 3u32;
8455 pub const TXFS_RM_STATE_STARTING: u32 = 1u32;
8456 pub const TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_REDO_LSN: u32 = 1u32;
8457 pub const TXFS_ROLLFORWARD_REDO_FLAG_USE_LAST_VIRTUAL_CLOCK: u32 = 2u32;
8458 #[repr(C)]
8459 pub struct TXFS_ROLLFORWARD_REDO_INFORMATION {
8460     pub LastVirtualClock: i64,
8461     pub LastRedoLsn: u64,
8462     pub HighestRecoveryLsn: u64,
8463     pub Flags: u32,
8464 }
8465 impl ::core::marker::Copy for TXFS_ROLLFORWARD_REDO_INFORMATION {}
8466 impl ::core::clone::Clone for TXFS_ROLLFORWARD_REDO_INFORMATION {
8467     fn clone(&self) -> Self {
8468         *self
8469     }
8470 }
8471 pub const TXFS_SAVEPOINT_CLEAR: u32 = 4u32;
8472 pub const TXFS_SAVEPOINT_CLEAR_ALL: u32 = 16u32;
8473 #[repr(C)]
8474 #[cfg(feature = "Win32_Foundation")]
8475 pub struct TXFS_SAVEPOINT_INFORMATION {
8476     pub KtmTransaction: super::super::Foundation::HANDLE,
8477     pub ActionCode: u32,
8478     pub SavepointId: u32,
8479 }
8480 #[cfg(feature = "Win32_Foundation")]
8481 impl ::core::marker::Copy for TXFS_SAVEPOINT_INFORMATION {}
8482 #[cfg(feature = "Win32_Foundation")]
8483 impl ::core::clone::Clone for TXFS_SAVEPOINT_INFORMATION {
8484     fn clone(&self) -> Self {
8485         *self
8486     }
8487 }
8488 pub const TXFS_SAVEPOINT_ROLLBACK: u32 = 2u32;
8489 pub const TXFS_SAVEPOINT_SET: u32 = 1u32;
8490 pub const TXFS_START_RM_FLAG_LOGGING_MODE: u32 = 1024u32;
8491 pub const TXFS_START_RM_FLAG_LOG_AUTO_SHRINK_PERCENTAGE: u32 = 32u32;
8492 pub const TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MAX: u32 = 1u32;
8493 pub const TXFS_START_RM_FLAG_LOG_CONTAINER_COUNT_MIN: u32 = 2u32;
8494 pub const TXFS_START_RM_FLAG_LOG_CONTAINER_SIZE: u32 = 4u32;
8495 pub const TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_NUM_CONTAINERS: u32 = 8u32;
8496 pub const TXFS_START_RM_FLAG_LOG_GROWTH_INCREMENT_PERCENT: u32 = 16u32;
8497 pub const TXFS_START_RM_FLAG_LOG_NO_CONTAINER_COUNT_MAX: u32 = 64u32;
8498 pub const TXFS_START_RM_FLAG_LOG_NO_CONTAINER_COUNT_MIN: u32 = 128u32;
8499 pub const TXFS_START_RM_FLAG_PREFER_AVAILABILITY: u32 = 8192u32;
8500 pub const TXFS_START_RM_FLAG_PREFER_CONSISTENCY: u32 = 4096u32;
8501 pub const TXFS_START_RM_FLAG_PRESERVE_CHANGES: u32 = 2048u32;
8502 pub const TXFS_START_RM_FLAG_RECOVER_BEST_EFFORT: u32 = 512u32;
8503 #[repr(C)]
8504 pub struct TXFS_START_RM_INFORMATION {
8505     pub Flags: u32,
8506     pub LogContainerSize: u64,
8507     pub LogContainerCountMin: u32,
8508     pub LogContainerCountMax: u32,
8509     pub LogGrowthIncrement: u32,
8510     pub LogAutoShrinkPercentage: u32,
8511     pub TmLogPathOffset: u32,
8512     pub TmLogPathLength: u16,
8513     pub LoggingMode: u16,
8514     pub LogPathLength: u16,
8515     pub Reserved: u16,
8516     pub LogPath: [u16; 1],
8517 }
8518 impl ::core::marker::Copy for TXFS_START_RM_INFORMATION {}
8519 impl ::core::clone::Clone for TXFS_START_RM_INFORMATION {
8520     fn clone(&self) -> Self {
8521         *self
8522     }
8523 }
8524 pub const TXFS_TRANSACTED_VERSION_NONTRANSACTED: u32 = 4294967294u32;
8525 pub const TXFS_TRANSACTED_VERSION_UNCOMMITTED: u32 = 4294967295u32;
8526 #[repr(C)]
8527 #[cfg(feature = "Win32_Foundation")]
8528 pub struct TXFS_TRANSACTION_ACTIVE_INFO {
8529     pub TransactionsActiveAtSnapshot: super::super::Foundation::BOOLEAN,
8530 }
8531 #[cfg(feature = "Win32_Foundation")]
8532 impl ::core::marker::Copy for TXFS_TRANSACTION_ACTIVE_INFO {}
8533 #[cfg(feature = "Win32_Foundation")]
8534 impl ::core::clone::Clone for TXFS_TRANSACTION_ACTIVE_INFO {
8535     fn clone(&self) -> Self {
8536         *self
8537     }
8538 }
8539 pub const TXFS_TRANSACTION_STATE_ACTIVE: u32 = 1u32;
8540 pub const TXFS_TRANSACTION_STATE_NONE: u32 = 0u32;
8541 pub const TXFS_TRANSACTION_STATE_NOTACTIVE: u32 = 3u32;
8542 pub const TXFS_TRANSACTION_STATE_PREPARED: u32 = 2u32;
8543 #[repr(C)]
8544 pub struct TXFS_WRITE_BACKUP_INFORMATION {
8545     pub Buffer: [u8; 1],
8546 }
8547 impl ::core::marker::Copy for TXFS_WRITE_BACKUP_INFORMATION {}
8548 impl ::core::clone::Clone for TXFS_WRITE_BACKUP_INFORMATION {
8549     fn clone(&self) -> Self {
8550         *self
8551     }
8552 }
8553 pub const UNDEFINE_ALTERNATE: u32 = 13u32;
8554 pub const UNDEFINE_PRIMARY: u32 = 12u32;
8555 pub const UNLOCK_ELEMENT: u32 = 1u32;
8556 pub const UNRECOVERED_READS_VALID: u32 = 8u32;
8557 pub const UNRECOVERED_WRITES_VALID: u32 = 2u32;
8558 pub type USN_DELETE_FLAGS = u32;
8559 pub const USN_DELETE_FLAG_DELETE: USN_DELETE_FLAGS = 1u32;
8560 pub const USN_DELETE_FLAG_NOTIFY: USN_DELETE_FLAGS = 2u32;
8561 pub const USN_DELETE_VALID_FLAGS: u32 = 3u32;
8562 #[repr(C)]
8563 pub struct USN_JOURNAL_DATA_V0 {
8564     pub UsnJournalID: u64,
8565     pub FirstUsn: i64,
8566     pub NextUsn: i64,
8567     pub LowestValidUsn: i64,
8568     pub MaxUsn: i64,
8569     pub MaximumSize: u64,
8570     pub AllocationDelta: u64,
8571 }
8572 impl ::core::marker::Copy for USN_JOURNAL_DATA_V0 {}
8573 impl ::core::clone::Clone for USN_JOURNAL_DATA_V0 {
8574     fn clone(&self) -> Self {
8575         *self
8576     }
8577 }
8578 #[repr(C)]
8579 pub struct USN_JOURNAL_DATA_V1 {
8580     pub UsnJournalID: u64,
8581     pub FirstUsn: i64,
8582     pub NextUsn: i64,
8583     pub LowestValidUsn: i64,
8584     pub MaxUsn: i64,
8585     pub MaximumSize: u64,
8586     pub AllocationDelta: u64,
8587     pub MinSupportedMajorVersion: u16,
8588     pub MaxSupportedMajorVersion: u16,
8589 }
8590 impl ::core::marker::Copy for USN_JOURNAL_DATA_V1 {}
8591 impl ::core::clone::Clone for USN_JOURNAL_DATA_V1 {
8592     fn clone(&self) -> Self {
8593         *self
8594     }
8595 }
8596 #[repr(C)]
8597 pub struct USN_JOURNAL_DATA_V2 {
8598     pub UsnJournalID: u64,
8599     pub FirstUsn: i64,
8600     pub NextUsn: i64,
8601     pub LowestValidUsn: i64,
8602     pub MaxUsn: i64,
8603     pub MaximumSize: u64,
8604     pub AllocationDelta: u64,
8605     pub MinSupportedMajorVersion: u16,
8606     pub MaxSupportedMajorVersion: u16,
8607     pub Flags: u32,
8608     pub RangeTrackChunkSize: u64,
8609     pub RangeTrackFileSizeThreshold: i64,
8610 }
8611 impl ::core::marker::Copy for USN_JOURNAL_DATA_V2 {}
8612 impl ::core::clone::Clone for USN_JOURNAL_DATA_V2 {
8613     fn clone(&self) -> Self {
8614         *self
8615     }
8616 }
8617 pub const USN_PAGE_SIZE: u32 = 4096u32;
8618 #[repr(C)]
8619 pub struct USN_RANGE_TRACK_OUTPUT {
8620     pub Usn: i64,
8621 }
8622 impl ::core::marker::Copy for USN_RANGE_TRACK_OUTPUT {}
8623 impl ::core::clone::Clone for USN_RANGE_TRACK_OUTPUT {
8624     fn clone(&self) -> Self {
8625         *self
8626     }
8627 }
8628 pub const USN_REASON_BASIC_INFO_CHANGE: u32 = 32768u32;
8629 pub const USN_REASON_CLOSE: u32 = 2147483648u32;
8630 pub const USN_REASON_COMPRESSION_CHANGE: u32 = 131072u32;
8631 pub const USN_REASON_DATA_EXTEND: u32 = 2u32;
8632 pub const USN_REASON_DATA_OVERWRITE: u32 = 1u32;
8633 pub const USN_REASON_DATA_TRUNCATION: u32 = 4u32;
8634 pub const USN_REASON_DESIRED_STORAGE_CLASS_CHANGE: u32 = 16777216u32;
8635 pub const USN_REASON_EA_CHANGE: u32 = 1024u32;
8636 pub const USN_REASON_ENCRYPTION_CHANGE: u32 = 262144u32;
8637 pub const USN_REASON_FILE_CREATE: u32 = 256u32;
8638 pub const USN_REASON_FILE_DELETE: u32 = 512u32;
8639 pub const USN_REASON_HARD_LINK_CHANGE: u32 = 65536u32;
8640 pub const USN_REASON_INDEXABLE_CHANGE: u32 = 16384u32;
8641 pub const USN_REASON_INTEGRITY_CHANGE: u32 = 8388608u32;
8642 pub const USN_REASON_NAMED_DATA_EXTEND: u32 = 32u32;
8643 pub const USN_REASON_NAMED_DATA_OVERWRITE: u32 = 16u32;
8644 pub const USN_REASON_NAMED_DATA_TRUNCATION: u32 = 64u32;
8645 pub const USN_REASON_OBJECT_ID_CHANGE: u32 = 524288u32;
8646 pub const USN_REASON_RENAME_NEW_NAME: u32 = 8192u32;
8647 pub const USN_REASON_RENAME_OLD_NAME: u32 = 4096u32;
8648 pub const USN_REASON_REPARSE_POINT_CHANGE: u32 = 1048576u32;
8649 pub const USN_REASON_SECURITY_CHANGE: u32 = 2048u32;
8650 pub const USN_REASON_STREAM_CHANGE: u32 = 2097152u32;
8651 pub const USN_REASON_TRANSACTED_CHANGE: u32 = 4194304u32;
8652 #[repr(C)]
8653 pub struct USN_RECORD_COMMON_HEADER {
8654     pub RecordLength: u32,
8655     pub MajorVersion: u16,
8656     pub MinorVersion: u16,
8657 }
8658 impl ::core::marker::Copy for USN_RECORD_COMMON_HEADER {}
8659 impl ::core::clone::Clone for USN_RECORD_COMMON_HEADER {
8660     fn clone(&self) -> Self {
8661         *self
8662     }
8663 }
8664 #[repr(C)]
8665 pub struct USN_RECORD_EXTENT {
8666     pub Offset: i64,
8667     pub Length: i64,
8668 }
8669 impl ::core::marker::Copy for USN_RECORD_EXTENT {}
8670 impl ::core::clone::Clone for USN_RECORD_EXTENT {
8671     fn clone(&self) -> Self {
8672         *self
8673     }
8674 }
8675 #[repr(C)]
8676 #[cfg(feature = "Win32_Storage_FileSystem")]
8677 pub union USN_RECORD_UNION {
8678     pub Header: USN_RECORD_COMMON_HEADER,
8679     pub V2: USN_RECORD_V2,
8680     pub V3: USN_RECORD_V3,
8681     pub V4: USN_RECORD_V4,
8682 }
8683 #[cfg(feature = "Win32_Storage_FileSystem")]
8684 impl ::core::marker::Copy for USN_RECORD_UNION {}
8685 #[cfg(feature = "Win32_Storage_FileSystem")]
8686 impl ::core::clone::Clone for USN_RECORD_UNION {
8687     fn clone(&self) -> Self {
8688         *self
8689     }
8690 }
8691 #[repr(C)]
8692 pub struct USN_RECORD_V2 {
8693     pub RecordLength: u32,
8694     pub MajorVersion: u16,
8695     pub MinorVersion: u16,
8696     pub FileReferenceNumber: u64,
8697     pub ParentFileReferenceNumber: u64,
8698     pub Usn: i64,
8699     pub TimeStamp: i64,
8700     pub Reason: u32,
8701     pub SourceInfo: u32,
8702     pub SecurityId: u32,
8703     pub FileAttributes: u32,
8704     pub FileNameLength: u16,
8705     pub FileNameOffset: u16,
8706     pub FileName: [u16; 1],
8707 }
8708 impl ::core::marker::Copy for USN_RECORD_V2 {}
8709 impl ::core::clone::Clone for USN_RECORD_V2 {
8710     fn clone(&self) -> Self {
8711         *self
8712     }
8713 }
8714 #[repr(C)]
8715 #[cfg(feature = "Win32_Storage_FileSystem")]
8716 pub struct USN_RECORD_V3 {
8717     pub RecordLength: u32,
8718     pub MajorVersion: u16,
8719     pub MinorVersion: u16,
8720     pub FileReferenceNumber: super::super::Storage::FileSystem::FILE_ID_128,
8721     pub ParentFileReferenceNumber: super::super::Storage::FileSystem::FILE_ID_128,
8722     pub Usn: i64,
8723     pub TimeStamp: i64,
8724     pub Reason: u32,
8725     pub SourceInfo: u32,
8726     pub SecurityId: u32,
8727     pub FileAttributes: u32,
8728     pub FileNameLength: u16,
8729     pub FileNameOffset: u16,
8730     pub FileName: [u16; 1],
8731 }
8732 #[cfg(feature = "Win32_Storage_FileSystem")]
8733 impl ::core::marker::Copy for USN_RECORD_V3 {}
8734 #[cfg(feature = "Win32_Storage_FileSystem")]
8735 impl ::core::clone::Clone for USN_RECORD_V3 {
8736     fn clone(&self) -> Self {
8737         *self
8738     }
8739 }
8740 #[repr(C)]
8741 #[cfg(feature = "Win32_Storage_FileSystem")]
8742 pub struct USN_RECORD_V4 {
8743     pub Header: USN_RECORD_COMMON_HEADER,
8744     pub FileReferenceNumber: super::super::Storage::FileSystem::FILE_ID_128,
8745     pub ParentFileReferenceNumber: super::super::Storage::FileSystem::FILE_ID_128,
8746     pub Usn: i64,
8747     pub Reason: u32,
8748     pub SourceInfo: USN_SOURCE_INFO_ID,
8749     pub RemainingExtents: u32,
8750     pub NumberOfExtents: u16,
8751     pub ExtentSize: u16,
8752     pub Extents: [USN_RECORD_EXTENT; 1],
8753 }
8754 #[cfg(feature = "Win32_Storage_FileSystem")]
8755 impl ::core::marker::Copy for USN_RECORD_V4 {}
8756 #[cfg(feature = "Win32_Storage_FileSystem")]
8757 impl ::core::clone::Clone for USN_RECORD_V4 {
8758     fn clone(&self) -> Self {
8759         *self
8760     }
8761 }
8762 pub type USN_SOURCE_INFO_ID = u32;
8763 pub const USN_SOURCE_AUXILIARY_DATA: USN_SOURCE_INFO_ID = 2u32;
8764 pub const USN_SOURCE_DATA_MANAGEMENT: USN_SOURCE_INFO_ID = 1u32;
8765 pub const USN_SOURCE_REPLICATION_MANAGEMENT: USN_SOURCE_INFO_ID = 4u32;
8766 pub const USN_SOURCE_CLIENT_REPLICATION_MANAGEMENT: USN_SOURCE_INFO_ID = 8u32;
8767 #[repr(C)]
8768 pub struct USN_TRACK_MODIFIED_RANGES {
8769     pub Flags: u32,
8770     pub Unused: u32,
8771     pub ChunkSize: u64,
8772     pub FileSizeThreshold: i64,
8773 }
8774 impl ::core::marker::Copy for USN_TRACK_MODIFIED_RANGES {}
8775 impl ::core::clone::Clone for USN_TRACK_MODIFIED_RANGES {
8776     fn clone(&self) -> Self {
8777         *self
8778     }
8779 }
8780 pub const VALID_NTFT: u32 = 192u32;
8781 pub const VENDOR_ID_LENGTH: u32 = 8u32;
8782 #[repr(C)]
8783 pub struct VERIFY_INFORMATION {
8784     pub StartingOffset: i64,
8785     pub Length: u32,
8786 }
8787 impl ::core::marker::Copy for VERIFY_INFORMATION {}
8788 impl ::core::clone::Clone for VERIFY_INFORMATION {
8789     fn clone(&self) -> Self {
8790         *self
8791     }
8792 }
8793 #[repr(C)]
8794 pub struct VIRTUALIZATION_INSTANCE_INFO_INPUT {
8795     pub NumberOfWorkerThreads: u32,
8796     pub Flags: u32,
8797 }
8798 impl ::core::marker::Copy for VIRTUALIZATION_INSTANCE_INFO_INPUT {}
8799 impl ::core::clone::Clone for VIRTUALIZATION_INSTANCE_INFO_INPUT {
8800     fn clone(&self) -> Self {
8801         *self
8802     }
8803 }
8804 #[repr(C)]
8805 pub struct VIRTUALIZATION_INSTANCE_INFO_INPUT_EX {
8806     pub HeaderSize: u16,
8807     pub Flags: u32,
8808     pub NotificationInfoSize: u32,
8809     pub NotificationInfoOffset: u16,
8810     pub ProviderMajorVersion: u16,
8811 }
8812 impl ::core::marker::Copy for VIRTUALIZATION_INSTANCE_INFO_INPUT_EX {}
8813 impl ::core::clone::Clone for VIRTUALIZATION_INSTANCE_INFO_INPUT_EX {
8814     fn clone(&self) -> Self {
8815         *self
8816     }
8817 }
8818 #[repr(C)]
8819 pub struct VIRTUALIZATION_INSTANCE_INFO_OUTPUT {
8820     pub VirtualizationInstanceID: ::windows_sys::core::GUID,
8821 }
8822 impl ::core::marker::Copy for VIRTUALIZATION_INSTANCE_INFO_OUTPUT {}
8823 impl ::core::clone::Clone for VIRTUALIZATION_INSTANCE_INFO_OUTPUT {
8824     fn clone(&self) -> Self {
8825         *self
8826     }
8827 }
8828 pub type VIRTUAL_STORAGE_BEHAVIOR_CODE = i32;
8829 pub const VirtualStorageBehaviorUndefined: VIRTUAL_STORAGE_BEHAVIOR_CODE = 0i32;
8830 pub const VirtualStorageBehaviorCacheWriteThrough: VIRTUAL_STORAGE_BEHAVIOR_CODE = 1i32;
8831 pub const VirtualStorageBehaviorCacheWriteBack: VIRTUAL_STORAGE_BEHAVIOR_CODE = 2i32;
8832 pub const VirtualStorageBehaviorStopIoProcessing: VIRTUAL_STORAGE_BEHAVIOR_CODE = 3i32;
8833 pub const VirtualStorageBehaviorRestartIoProcessing: VIRTUAL_STORAGE_BEHAVIOR_CODE = 4i32;
8834 #[repr(C)]
8835 pub struct VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT {
8836     pub Size: u32,
8837     pub BehaviorCode: VIRTUAL_STORAGE_BEHAVIOR_CODE,
8838 }
8839 impl ::core::marker::Copy for VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT {}
8840 impl ::core::clone::Clone for VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT {
8841     fn clone(&self) -> Self {
8842         *self
8843     }
8844 }
8845 #[repr(C)]
8846 pub struct VOLUME_BITMAP_BUFFER {
8847     pub StartingLcn: i64,
8848     pub BitmapSize: i64,
8849     pub Buffer: [u8; 1],
8850 }
8851 impl ::core::marker::Copy for VOLUME_BITMAP_BUFFER {}
8852 impl ::core::clone::Clone for VOLUME_BITMAP_BUFFER {
8853     fn clone(&self) -> Self {
8854         *self
8855     }
8856 }
8857 #[repr(C)]
8858 pub struct VOLUME_DISK_EXTENTS {
8859     pub NumberOfDiskExtents: u32,
8860     pub Extents: [DISK_EXTENT; 1],
8861 }
8862 impl ::core::marker::Copy for VOLUME_DISK_EXTENTS {}
8863 impl ::core::clone::Clone for VOLUME_DISK_EXTENTS {
8864     fn clone(&self) -> Self {
8865         *self
8866     }
8867 }
8868 #[repr(C)]
8869 pub struct VOLUME_GET_GPT_ATTRIBUTES_INFORMATION {
8870     pub GptAttributes: u64,
8871 }
8872 impl ::core::marker::Copy for VOLUME_GET_GPT_ATTRIBUTES_INFORMATION {}
8873 impl ::core::clone::Clone for VOLUME_GET_GPT_ATTRIBUTES_INFORMATION {
8874     fn clone(&self) -> Self {
8875         *self
8876     }
8877 }
8878 pub const VOLUME_IS_DIRTY: u32 = 1u32;
8879 pub const VOLUME_SESSION_OPEN: u32 = 4u32;
8880 pub const VOLUME_UPGRADE_SCHEDULED: u32 = 2u32;
8881 #[repr(C)]
8882 pub struct WIM_PROVIDER_ADD_OVERLAY_INPUT {
8883     pub WimType: u32,
8884     pub WimIndex: u32,
8885     pub WimFileNameOffset: u32,
8886     pub WimFileNameLength: u32,
8887 }
8888 impl ::core::marker::Copy for WIM_PROVIDER_ADD_OVERLAY_INPUT {}
8889 impl ::core::clone::Clone for WIM_PROVIDER_ADD_OVERLAY_INPUT {
8890     fn clone(&self) -> Self {
8891         *self
8892     }
8893 }
8894 pub const WIM_PROVIDER_CURRENT_VERSION: u32 = 1u32;
8895 pub const WIM_PROVIDER_EXTERNAL_FLAG_NOT_ACTIVE: u32 = 1u32;
8896 pub const WIM_PROVIDER_EXTERNAL_FLAG_SUSPENDED: u32 = 2u32;
8897 #[repr(C)]
8898 pub struct WIM_PROVIDER_EXTERNAL_INFO {
8899     pub Version: u32,
8900     pub Flags: u32,
8901     pub DataSourceId: i64,
8902     pub ResourceHash: [u8; 20],
8903 }
8904 impl ::core::marker::Copy for WIM_PROVIDER_EXTERNAL_INFO {}
8905 impl ::core::clone::Clone for WIM_PROVIDER_EXTERNAL_INFO {
8906     fn clone(&self) -> Self {
8907         *self
8908     }
8909 }
8910 #[repr(C)]
8911 pub struct WIM_PROVIDER_OVERLAY_ENTRY {
8912     pub NextEntryOffset: u32,
8913     pub DataSourceId: i64,
8914     pub WimGuid: ::windows_sys::core::GUID,
8915     pub WimFileNameOffset: u32,
8916     pub WimType: u32,
8917     pub WimIndex: u32,
8918     pub Flags: u32,
8919 }
8920 impl ::core::marker::Copy for WIM_PROVIDER_OVERLAY_ENTRY {}
8921 impl ::core::clone::Clone for WIM_PROVIDER_OVERLAY_ENTRY {
8922     fn clone(&self) -> Self {
8923         *self
8924     }
8925 }
8926 #[repr(C)]
8927 pub struct WIM_PROVIDER_REMOVE_OVERLAY_INPUT {
8928     pub DataSourceId: i64,
8929 }
8930 impl ::core::marker::Copy for WIM_PROVIDER_REMOVE_OVERLAY_INPUT {}
8931 impl ::core::clone::Clone for WIM_PROVIDER_REMOVE_OVERLAY_INPUT {
8932     fn clone(&self) -> Self {
8933         *self
8934     }
8935 }
8936 #[repr(C)]
8937 pub struct WIM_PROVIDER_SUSPEND_OVERLAY_INPUT {
8938     pub DataSourceId: i64,
8939 }
8940 impl ::core::marker::Copy for WIM_PROVIDER_SUSPEND_OVERLAY_INPUT {}
8941 impl ::core::clone::Clone for WIM_PROVIDER_SUSPEND_OVERLAY_INPUT {
8942     fn clone(&self) -> Self {
8943         *self
8944     }
8945 }
8946 #[repr(C)]
8947 pub struct WIM_PROVIDER_UPDATE_OVERLAY_INPUT {
8948     pub DataSourceId: i64,
8949     pub WimFileNameOffset: u32,
8950     pub WimFileNameLength: u32,
8951 }
8952 impl ::core::marker::Copy for WIM_PROVIDER_UPDATE_OVERLAY_INPUT {}
8953 impl ::core::clone::Clone for WIM_PROVIDER_UPDATE_OVERLAY_INPUT {
8954     fn clone(&self) -> Self {
8955         *self
8956     }
8957 }
8958 pub const WOF_CURRENT_VERSION: u32 = 1u32;
8959 #[repr(C)]
8960 #[cfg(feature = "Win32_Storage_FileSystem")]
8961 pub struct WOF_EXTERNAL_FILE_ID {
8962     pub FileId: super::super::Storage::FileSystem::FILE_ID_128,
8963 }
8964 #[cfg(feature = "Win32_Storage_FileSystem")]
8965 impl ::core::marker::Copy for WOF_EXTERNAL_FILE_ID {}
8966 #[cfg(feature = "Win32_Storage_FileSystem")]
8967 impl ::core::clone::Clone for WOF_EXTERNAL_FILE_ID {
8968     fn clone(&self) -> Self {
8969         *self
8970     }
8971 }
8972 #[repr(C)]
8973 pub struct WOF_EXTERNAL_INFO {
8974     pub Version: u32,
8975     pub Provider: u32,
8976 }
8977 impl ::core::marker::Copy for WOF_EXTERNAL_INFO {}
8978 impl ::core::clone::Clone for WOF_EXTERNAL_INFO {
8979     fn clone(&self) -> Self {
8980         *self
8981     }
8982 }
8983 pub const WOF_PROVIDER_CLOUD: u32 = 3u32;
8984 #[repr(C)]
8985 pub struct WOF_VERSION_INFO {
8986     pub WofVersion: u32,
8987 }
8988 impl ::core::marker::Copy for WOF_VERSION_INFO {}
8989 impl ::core::clone::Clone for WOF_VERSION_INFO {
8990     fn clone(&self) -> Self {
8991         *self
8992     }
8993 }
8994 pub type WRITE_CACHE_CHANGE = i32;
8995 pub const WriteCacheChangeUnknown: WRITE_CACHE_CHANGE = 0i32;
8996 pub const WriteCacheNotChangeable: WRITE_CACHE_CHANGE = 1i32;
8997 pub const WriteCacheChangeable: WRITE_CACHE_CHANGE = 2i32;
8998 pub type WRITE_CACHE_ENABLE = i32;
8999 pub const WriteCacheEnableUnknown: WRITE_CACHE_ENABLE = 0i32;
9000 pub const WriteCacheDisabled: WRITE_CACHE_ENABLE = 1i32;
9001 pub const WriteCacheEnabled: WRITE_CACHE_ENABLE = 2i32;
9002 pub type WRITE_CACHE_TYPE = i32;
9003 pub const WriteCacheTypeUnknown: WRITE_CACHE_TYPE = 0i32;
9004 pub const WriteCacheTypeNone: WRITE_CACHE_TYPE = 1i32;
9005 pub const WriteCacheTypeWriteBack: WRITE_CACHE_TYPE = 2i32;
9006 pub const WriteCacheTypeWriteThrough: WRITE_CACHE_TYPE = 3i32;
9007 pub const WRITE_COMPRESSION_INFO_VALID: u32 = 16u32;
9008 pub type WRITE_THROUGH = i32;
9009 pub const WriteThroughUnknown: WRITE_THROUGH = 0i32;
9010 pub const WriteThroughNotSupported: WRITE_THROUGH = 1i32;
9011 pub const WriteThroughSupported: WRITE_THROUGH = 2i32;
9012 #[repr(C)]
9013 pub struct WRITE_USN_REASON_INPUT {
9014     pub Flags: u32,
9015     pub UsnReasonToWrite: u32,
9016 }
9017 impl ::core::marker::Copy for WRITE_USN_REASON_INPUT {}
9018 impl ::core::clone::Clone for WRITE_USN_REASON_INPUT {
9019     fn clone(&self) -> Self {
9020         *self
9021     }
9022 }
9023 pub type _DEVICEDUMP_COLLECTION_TYPE = i32;
9024 pub const TCCollectionBugCheck: _DEVICEDUMP_COLLECTION_TYPE = 1i32;
9025 pub const TCCollectionApplicationRequested: _DEVICEDUMP_COLLECTION_TYPE = 2i32;
9026 pub const TCCollectionDeviceRequested: _DEVICEDUMP_COLLECTION_TYPE = 3i32;