winfsp-sys 0.12.1+winfsp-2.1

/* automatically generated by rust-bindgen 0.72.0 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
        };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            byte | mask
        } else {
            byte & !mask
        }
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
        };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
pub const FSP_FSCTL_PRODUCT_NAME: &[u8; 7] = b"WinFsp\0";
pub const FSP_FSCTL_PRODUCT_FILE_NAME: &[u8; 7] = b"winfsp\0";
pub const FSP_FSCTL_DRIVER_NAME: &[u8; 7] = b"WinFsp\0";
pub const FSP_FSCTL_DISK_DEVICE_NAME: &[u8; 12] = b"WinFsp.Disk\0";
pub const FSP_FSCTL_NET_DEVICE_NAME: &[u8; 11] = b"WinFsp.Net\0";
pub const FSP_FSCTL_MUP_DEVICE_NAME: &[u8; 11] = b"WinFsp.Mup\0";
pub const FSP_FSCTL_PRODUCT_REGKEY: &[u8; 16] = b"Software\\WinFsp\0";
pub const FSP_FSCTL_PRODUCT_REGKEY_WOW64: u32 = 512;
pub const FSP_FSCTL_PRODUCT_FULL_REGKEY: &[u8; 28] = b"Software\\WOW6432Node\\WinFsp\0";
pub const FSP_FSCTL_PRODUCT_FILE_ARCH: &[u8; 4] = b"x64\0";
pub const FSP_FSCTL_DEFAULT_ALIGNMENT: u32 = 8;
pub const FSP_FSCTL_VOLUME_PARAMS_PREFIX: &[u8; 15] = b"\\VolumeParams=\0";
pub const FSP_FSCTL_TRANSACT_REQ_SIZEMAX: u32 = 16320;
pub const FSP_FSCTL_TRANSACT_RSP_SIZEMAX: u32 = 16384;
pub const FSP_FSCTL_TRANSACT_BATCH_BUFFER_SIZEMIN: u32 = 65536;
pub const FSP_FSCTL_TRANSACT_BUFFER_SIZEMIN: u32 = 16320;
pub const FSP_FSCTL_DEVICECONTROL_SIZEMAX: u32 = 4096;
pub const FSP_DLLNAME: &[u8; 15] = b"winfsp-x64.dll\0";
pub const FSP_DLLPATH: &[u8; 19] = b"bin\\winfsp-x64.dll\0";
pub const FSP_LAUNCH_REGKEY: &[u8; 25] = b"Software\\WinFsp\\Services\0";
pub const FSP_LAUNCH_REGKEY_WOW64: u32 = 512;
pub const FSP_LAUNCH_FULL_REGKEY: &[u8; 37] = b"Software\\WOW6432Node\\WinFsp\\Services\0";
pub const FSP_LAUNCH_PIPE_NAME: &[u8; 55] =
    b"\\\\.\\pipe\\WinFsp.{14E7137D-22B4-437A-B0C1-D21D1BDF3767}\0";
pub const FSP_LAUNCH_PIPE_BUFFER_SIZE: u32 = 4096;
pub const FSP_LAUNCH_PIPE_SDDL: &[u8; 52] =
    b"O:SYG:SYD:P(A;;GA;;;SY)(A;;GA;;;BA)(A;;GRDCCR;;;WD)\0";
pub const FSP_LAUNCH_SERVICE_DEFAULT_SDDL: &[u8; 36] = b"D:P(A;;RPWPLC;;;SY)(A;;RPWPLC;;;BA)\0";
pub const FSP_LAUNCH_SERVICE_WORLD_SDDL: &[u8; 20] = b"D:P(A;;RPWPLC;;;WD)\0";
pub type va_list = *mut ::std::os::raw::c_char;
pub type wchar_t = ::std::os::raw::c_ushort;
pub type ULONG = ::std::os::raw::c_ulong;
pub type PULONG = *mut ULONG;
pub type USHORT = ::std::os::raw::c_ushort;
pub type UCHAR = ::std::os::raw::c_uchar;
pub type DWORD = ::std::os::raw::c_ulong;
pub type BYTE = ::std::os::raw::c_uchar;
pub type WORD = ::std::os::raw::c_ushort;
pub type UINT8 = ::std::os::raw::c_uchar;
pub type UINT16 = ::std::os::raw::c_ushort;
pub type UINT32 = ::std::os::raw::c_uint;
pub type PUINT32 = *mut ::std::os::raw::c_uint;
pub type UINT64 = ::std::os::raw::c_ulonglong;
pub type ULONG_PTR = ::std::os::raw::c_ulonglong;
pub type SIZE_T = ULONG_PTR;
pub type PSIZE_T = *mut ULONG_PTR;
pub type PVOID = *mut ::std::os::raw::c_void;
pub type CHAR = ::std::os::raw::c_char;
pub type LONG = ::std::os::raw::c_long;
pub type WCHAR = wchar_t;
pub type PWCHAR = *mut WCHAR;
pub type PWSTR = *mut WCHAR;
pub type HANDLE = *mut ::std::os::raw::c_void;
pub type PHANDLE = *mut HANDLE;
pub type BOOLEAN = BYTE;
pub type PBOOLEAN = *mut BOOLEAN;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _LIST_ENTRY {
    pub Flink: *mut _LIST_ENTRY,
    pub Blink: *mut _LIST_ENTRY,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _LIST_ENTRY"][::std::mem::size_of::<_LIST_ENTRY>() - 16usize];
    ["Alignment of _LIST_ENTRY"][::std::mem::align_of::<_LIST_ENTRY>() - 8usize];
    ["Offset of field: _LIST_ENTRY::Flink"][::std::mem::offset_of!(_LIST_ENTRY, Flink) - 0usize];
    ["Offset of field: _LIST_ENTRY::Blink"][::std::mem::offset_of!(_LIST_ENTRY, Blink) - 8usize];
};
impl Default for _LIST_ENTRY {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type LIST_ENTRY = _LIST_ENTRY;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GUID {
    pub Data1: ::std::os::raw::c_ulong,
    pub Data2: ::std::os::raw::c_ushort,
    pub Data3: ::std::os::raw::c_ushort,
    pub Data4: [::std::os::raw::c_uchar; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _GUID"][::std::mem::size_of::<_GUID>() - 16usize];
    ["Alignment of _GUID"][::std::mem::align_of::<_GUID>() - 4usize];
    ["Offset of field: _GUID::Data1"][::std::mem::offset_of!(_GUID, Data1) - 0usize];
    ["Offset of field: _GUID::Data2"][::std::mem::offset_of!(_GUID, Data2) - 4usize];
    ["Offset of field: _GUID::Data3"][::std::mem::offset_of!(_GUID, Data3) - 6usize];
    ["Offset of field: _GUID::Data4"][::std::mem::offset_of!(_GUID, Data4) - 8usize];
};
pub type GUID = _GUID;
pub type PSECURITY_DESCRIPTOR = PVOID;
pub type PSID = PVOID;
pub type ACCESS_MASK = DWORD;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _GENERIC_MAPPING {
    pub GenericRead: ACCESS_MASK,
    pub GenericWrite: ACCESS_MASK,
    pub GenericExecute: ACCESS_MASK,
    pub GenericAll: ACCESS_MASK,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _GENERIC_MAPPING"][::std::mem::size_of::<_GENERIC_MAPPING>() - 16usize];
    ["Alignment of _GENERIC_MAPPING"][::std::mem::align_of::<_GENERIC_MAPPING>() - 4usize];
    ["Offset of field: _GENERIC_MAPPING::GenericRead"]
        [::std::mem::offset_of!(_GENERIC_MAPPING, GenericRead) - 0usize];
    ["Offset of field: _GENERIC_MAPPING::GenericWrite"]
        [::std::mem::offset_of!(_GENERIC_MAPPING, GenericWrite) - 4usize];
    ["Offset of field: _GENERIC_MAPPING::GenericExecute"]
        [::std::mem::offset_of!(_GENERIC_MAPPING, GenericExecute) - 8usize];
    ["Offset of field: _GENERIC_MAPPING::GenericAll"]
        [::std::mem::offset_of!(_GENERIC_MAPPING, GenericAll) - 12usize];
};
pub type GENERIC_MAPPING = _GENERIC_MAPPING;
pub type PGENERIC_MAPPING = *mut GENERIC_MAPPING;
pub type SECURITY_INFORMATION = DWORD;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _RTL_CRITICAL_SECTION_DEBUG {
    pub Type: WORD,
    pub CreatorBackTraceIndex: WORD,
    pub CriticalSection: *mut _RTL_CRITICAL_SECTION,
    pub ProcessLocksList: LIST_ENTRY,
    pub EntryCount: DWORD,
    pub ContentionCount: DWORD,
    pub Flags: DWORD,
    pub CreatorBackTraceIndexHigh: WORD,
    pub Identifier: WORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _RTL_CRITICAL_SECTION_DEBUG"]
        [::std::mem::size_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 48usize];
    ["Alignment of _RTL_CRITICAL_SECTION_DEBUG"]
        [::std::mem::align_of::<_RTL_CRITICAL_SECTION_DEBUG>() - 8usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Type"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Type) - 0usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndex"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex) - 2usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CriticalSection"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CriticalSection) - 8usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ProcessLocksList"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList) - 16usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::EntryCount"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, EntryCount) - 32usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::ContentionCount"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, ContentionCount) - 36usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Flags"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Flags) - 40usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::CreatorBackTraceIndexHigh"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndexHigh) - 44usize];
    ["Offset of field: _RTL_CRITICAL_SECTION_DEBUG::Identifier"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION_DEBUG, Identifier) - 46usize];
};
impl Default for _RTL_CRITICAL_SECTION_DEBUG {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type PRTL_CRITICAL_SECTION_DEBUG = *mut _RTL_CRITICAL_SECTION_DEBUG;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _RTL_CRITICAL_SECTION {
    pub DebugInfo: PRTL_CRITICAL_SECTION_DEBUG,
    pub LockCount: LONG,
    pub RecursionCount: LONG,
    pub OwningThread: HANDLE,
    pub LockSemaphore: HANDLE,
    pub SpinCount: ULONG_PTR,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _RTL_CRITICAL_SECTION"][::std::mem::size_of::<_RTL_CRITICAL_SECTION>() - 40usize];
    ["Alignment of _RTL_CRITICAL_SECTION"]
        [::std::mem::align_of::<_RTL_CRITICAL_SECTION>() - 8usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::DebugInfo"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, DebugInfo) - 0usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::LockCount"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockCount) - 8usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::RecursionCount"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, RecursionCount) - 12usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::OwningThread"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, OwningThread) - 16usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::LockSemaphore"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, LockSemaphore) - 24usize];
    ["Offset of field: _RTL_CRITICAL_SECTION::SpinCount"]
        [::std::mem::offset_of!(_RTL_CRITICAL_SECTION, SpinCount) - 32usize];
};
impl Default for _RTL_CRITICAL_SECTION {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type RTL_CRITICAL_SECTION = _RTL_CRITICAL_SECTION;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _RTL_SRWLOCK {
    pub Ptr: PVOID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _RTL_SRWLOCK"][::std::mem::size_of::<_RTL_SRWLOCK>() - 8usize];
    ["Alignment of _RTL_SRWLOCK"][::std::mem::align_of::<_RTL_SRWLOCK>() - 8usize];
    ["Offset of field: _RTL_SRWLOCK::Ptr"][::std::mem::offset_of!(_RTL_SRWLOCK, Ptr) - 0usize];
};
impl Default for _RTL_SRWLOCK {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type RTL_SRWLOCK = _RTL_SRWLOCK;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _FILETIME {
    pub dwLowDateTime: DWORD,
    pub dwHighDateTime: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FILETIME"][::std::mem::size_of::<_FILETIME>() - 8usize];
    ["Alignment of _FILETIME"][::std::mem::align_of::<_FILETIME>() - 4usize];
    ["Offset of field: _FILETIME::dwLowDateTime"]
        [::std::mem::offset_of!(_FILETIME, dwLowDateTime) - 0usize];
    ["Offset of field: _FILETIME::dwHighDateTime"]
        [::std::mem::offset_of!(_FILETIME, dwHighDateTime) - 4usize];
};
pub type PFILETIME = *mut _FILETIME;
pub type CRITICAL_SECTION = RTL_CRITICAL_SECTION;
pub type SRWLOCK = RTL_SRWLOCK;
pub type NTSTATUS = LONG;
pub type PNTSTATUS = *mut NTSTATUS;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct SERVICE_STATUS_HANDLE__ {
    pub unused: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of SERVICE_STATUS_HANDLE__"][::std::mem::size_of::<SERVICE_STATUS_HANDLE__>() - 4usize];
    ["Alignment of SERVICE_STATUS_HANDLE__"]
        [::std::mem::align_of::<SERVICE_STATUS_HANDLE__>() - 4usize];
    ["Offset of field: SERVICE_STATUS_HANDLE__::unused"]
        [::std::mem::offset_of!(SERVICE_STATUS_HANDLE__, unused) - 0usize];
};
pub type SERVICE_STATUS_HANDLE = *mut SERVICE_STATUS_HANDLE__;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _SERVICE_STATUS {
    pub dwServiceType: DWORD,
    pub dwCurrentState: DWORD,
    pub dwControlsAccepted: DWORD,
    pub dwWin32ExitCode: DWORD,
    pub dwServiceSpecificExitCode: DWORD,
    pub dwCheckPoint: DWORD,
    pub dwWaitHint: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _SERVICE_STATUS"][::std::mem::size_of::<_SERVICE_STATUS>() - 28usize];
    ["Alignment of _SERVICE_STATUS"][::std::mem::align_of::<_SERVICE_STATUS>() - 4usize];
    ["Offset of field: _SERVICE_STATUS::dwServiceType"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwServiceType) - 0usize];
    ["Offset of field: _SERVICE_STATUS::dwCurrentState"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwCurrentState) - 4usize];
    ["Offset of field: _SERVICE_STATUS::dwControlsAccepted"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwControlsAccepted) - 8usize];
    ["Offset of field: _SERVICE_STATUS::dwWin32ExitCode"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwWin32ExitCode) - 12usize];
    ["Offset of field: _SERVICE_STATUS::dwServiceSpecificExitCode"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwServiceSpecificExitCode) - 16usize];
    ["Offset of field: _SERVICE_STATUS::dwCheckPoint"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwCheckPoint) - 20usize];
    ["Offset of field: _SERVICE_STATUS::dwWaitHint"]
        [::std::mem::offset_of!(_SERVICE_STATUS, dwWaitHint) - 24usize];
};
pub type SERVICE_STATUS = _SERVICE_STATUS;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IO_STATUS_BLOCK {
    pub __bindgen_anon_1: _IO_STATUS_BLOCK__bindgen_ty_1,
    pub Information: ULONG_PTR,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IO_STATUS_BLOCK__bindgen_ty_1 {
    pub Status: NTSTATUS,
    pub Pointer: PVOID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _IO_STATUS_BLOCK__bindgen_ty_1"]
        [::std::mem::size_of::<_IO_STATUS_BLOCK__bindgen_ty_1>() - 8usize];
    ["Alignment of _IO_STATUS_BLOCK__bindgen_ty_1"]
        [::std::mem::align_of::<_IO_STATUS_BLOCK__bindgen_ty_1>() - 8usize];
    ["Offset of field: _IO_STATUS_BLOCK__bindgen_ty_1::Status"]
        [::std::mem::offset_of!(_IO_STATUS_BLOCK__bindgen_ty_1, Status) - 0usize];
    ["Offset of field: _IO_STATUS_BLOCK__bindgen_ty_1::Pointer"]
        [::std::mem::offset_of!(_IO_STATUS_BLOCK__bindgen_ty_1, Pointer) - 0usize];
};
impl Default for _IO_STATUS_BLOCK__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _IO_STATUS_BLOCK"][::std::mem::size_of::<_IO_STATUS_BLOCK>() - 16usize];
    ["Alignment of _IO_STATUS_BLOCK"][::std::mem::align_of::<_IO_STATUS_BLOCK>() - 8usize];
    ["Offset of field: _IO_STATUS_BLOCK::Information"]
        [::std::mem::offset_of!(_IO_STATUS_BLOCK, Information) - 8usize];
};
impl Default for _IO_STATUS_BLOCK {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type PIO_STATUS_BLOCK = *mut _IO_STATUS_BLOCK;
unsafe extern "C" {
    pub static FspFsctlDeviceClassGuid: GUID;
}
unsafe extern "C" {
    pub static FspFsvrtDeviceClassGuid: GUID;
}
pub const FspFsctlTransactReservedKind: _bindgen_ty_4 = 0;
pub const FspFsctlTransactCreateKind: _bindgen_ty_4 = 1;
pub const FspFsctlTransactOverwriteKind: _bindgen_ty_4 = 2;
pub const FspFsctlTransactCleanupKind: _bindgen_ty_4 = 3;
pub const FspFsctlTransactCloseKind: _bindgen_ty_4 = 4;
pub const FspFsctlTransactReadKind: _bindgen_ty_4 = 5;
pub const FspFsctlTransactWriteKind: _bindgen_ty_4 = 6;
pub const FspFsctlTransactQueryInformationKind: _bindgen_ty_4 = 7;
pub const FspFsctlTransactSetInformationKind: _bindgen_ty_4 = 8;
pub const FspFsctlTransactQueryEaKind: _bindgen_ty_4 = 9;
pub const FspFsctlTransactSetEaKind: _bindgen_ty_4 = 10;
pub const FspFsctlTransactFlushBuffersKind: _bindgen_ty_4 = 11;
pub const FspFsctlTransactQueryVolumeInformationKind: _bindgen_ty_4 = 12;
pub const FspFsctlTransactSetVolumeInformationKind: _bindgen_ty_4 = 13;
pub const FspFsctlTransactQueryDirectoryKind: _bindgen_ty_4 = 14;
pub const FspFsctlTransactFileSystemControlKind: _bindgen_ty_4 = 15;
pub const FspFsctlTransactDeviceControlKind: _bindgen_ty_4 = 16;
pub const FspFsctlTransactShutdownKind: _bindgen_ty_4 = 17;
pub const FspFsctlTransactLockControlKind: _bindgen_ty_4 = 18;
pub const FspFsctlTransactQuerySecurityKind: _bindgen_ty_4 = 19;
pub const FspFsctlTransactSetSecurityKind: _bindgen_ty_4 = 20;
pub const FspFsctlTransactQueryStreamInformationKind: _bindgen_ty_4 = 21;
pub const FspFsctlTransactKindCount: _bindgen_ty_4 = 22;
pub type _bindgen_ty_4 = ::std::os::raw::c_int;
pub const FspFsctlTransactTimeoutMinimum: _bindgen_ty_5 = 1000;
pub const FspFsctlTransactTimeoutMaximum: _bindgen_ty_5 = 10000;
pub const FspFsctlTransactTimeoutDefault: _bindgen_ty_5 = 1000;
pub const FspFsctlIrpTimeoutMinimum: _bindgen_ty_5 = 60000;
pub const FspFsctlIrpTimeoutMaximum: _bindgen_ty_5 = 600000;
pub const FspFsctlIrpTimeoutDefault: _bindgen_ty_5 = 300000;
pub const FspFsctlIrpTimeoutDebug: _bindgen_ty_5 = 142;
pub const FspFsctlIrpCapacityMinimum: _bindgen_ty_5 = 100;
pub const FspFsctlIrpCapacityMaximum: _bindgen_ty_5 = 1000;
pub const FspFsctlIrpCapacityDefault: _bindgen_ty_5 = 1000;
pub type _bindgen_ty_5 = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSP_FSCTL_VOLUME_PARAMS_V0 {
    pub Version: UINT16,
    pub SectorSize: UINT16,
    pub SectorsPerAllocationUnit: UINT16,
    pub MaxComponentLength: UINT16,
    pub VolumeCreationTime: UINT64,
    pub VolumeSerialNumber: UINT32,
    pub TransactTimeout: UINT32,
    pub IrpTimeout: UINT32,
    pub IrpCapacity: UINT32,
    pub FileInfoTimeout: UINT32,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub Prefix: [WCHAR; 192usize],
    pub FileSystemName: [WCHAR; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_VOLUME_PARAMS_V0"]
        [::std::mem::size_of::<FSP_FSCTL_VOLUME_PARAMS_V0>() - 456usize];
    ["Alignment of FSP_FSCTL_VOLUME_PARAMS_V0"]
        [::std::mem::align_of::<FSP_FSCTL_VOLUME_PARAMS_V0>() - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::Version"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, Version) - 0usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::SectorSize"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, SectorSize) - 2usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::SectorsPerAllocationUnit"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, SectorsPerAllocationUnit) - 4usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::MaxComponentLength"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, MaxComponentLength) - 6usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::VolumeCreationTime"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, VolumeCreationTime) - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::VolumeSerialNumber"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, VolumeSerialNumber) - 16usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::TransactTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, TransactTimeout) - 20usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::IrpTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, IrpTimeout) - 24usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::IrpCapacity"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, IrpCapacity) - 28usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::FileInfoTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, FileInfoTimeout) - 32usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::Prefix"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, Prefix) - 40usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS_V0::FileSystemName"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS_V0, FileSystemName) - 424usize];
};
impl Default for FSP_FSCTL_VOLUME_PARAMS_V0 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl FSP_FSCTL_VOLUME_PARAMS_V0 {
    #[inline]
    pub fn CaseSensitiveSearch(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CaseSensitiveSearch(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CaseSensitiveSearch_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CaseSensitiveSearch_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn CasePreservedNames(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CasePreservedNames(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CasePreservedNames_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CasePreservedNames_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UnicodeOnDisk(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UnicodeOnDisk(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UnicodeOnDisk_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UnicodeOnDisk_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PersistentAcls(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PersistentAcls(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PersistentAcls_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                3usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PersistentAcls_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReparsePoints(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReparsePoints(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReparsePoints_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReparsePoints_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReparsePointsAccessCheck(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReparsePointsAccessCheck(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReparsePointsAccessCheck_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                5usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReparsePointsAccessCheck_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn NamedStreams(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_NamedStreams(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn NamedStreams_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                6usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_NamedStreams_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HardLinks(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HardLinks(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HardLinks_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                7usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HardLinks_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ExtendedAttributes(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ExtendedAttributes(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ExtendedAttributes_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                8usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ExtendedAttributes_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReadOnlyVolume(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReadOnlyVolume(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReadOnlyVolume_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                9usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReadOnlyVolume_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PostCleanupWhenModifiedOnly(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PostCleanupWhenModifiedOnly(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PostCleanupWhenModifiedOnly_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                10usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PostCleanupWhenModifiedOnly_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PassQueryDirectoryPattern(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PassQueryDirectoryPattern(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PassQueryDirectoryPattern_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                11usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PassQueryDirectoryPattern_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn AlwaysUseDoubleBuffering(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_AlwaysUseDoubleBuffering(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn AlwaysUseDoubleBuffering_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                12usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_AlwaysUseDoubleBuffering_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PassQueryDirectoryFileName(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PassQueryDirectoryFileName(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PassQueryDirectoryFileName_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                13usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PassQueryDirectoryFileName_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn FlushAndPurgeOnCleanup(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_FlushAndPurgeOnCleanup(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn FlushAndPurgeOnCleanup_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                14usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_FlushAndPurgeOnCleanup_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DeviceControl(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DeviceControl(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DeviceControl_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                15usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DeviceControl_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmFileContextIsUserContext2(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmFileContextIsUserContext2(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmFileContextIsUserContext2_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                16usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmFileContextIsUserContext2_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmFileContextIsFullContext(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmFileContextIsFullContext(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmFileContextIsFullContext_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                17usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmFileContextIsFullContext_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmNoReparsePointsDirCheck(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(18usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                18usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                18usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 5u8) as u32) }
    }
    #[inline]
    pub fn set_UmReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(19usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                19usize,
                5u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                19usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn AllowOpenInKernelMode(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_AllowOpenInKernelMode(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn AllowOpenInKernelMode_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                24usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_AllowOpenInKernelMode_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn CasePreservedExtendedAttributes(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CasePreservedExtendedAttributes(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(25usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CasePreservedExtendedAttributes_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                25usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CasePreservedExtendedAttributes_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                25usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn WslFeatures(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_WslFeatures(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(26usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn WslFeatures_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                26usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_WslFeatures_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                26usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DirectoryMarkerAsNextOffset(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DirectoryMarkerAsNextOffset(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DirectoryMarkerAsNextOffset_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                27usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DirectoryMarkerAsNextOffset_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                27usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn RejectIrpPriorToTransact0(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_RejectIrpPriorToTransact0(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn RejectIrpPriorToTransact0_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                28usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_RejectIrpPriorToTransact0_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SupportsPosixUnlinkRename(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SupportsPosixUnlinkRename(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(29usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SupportsPosixUnlinkRename_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                29usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SupportsPosixUnlinkRename_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                29usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PostDispositionWhenNecessaryOnly(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PostDispositionWhenNecessaryOnly(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PostDispositionWhenNecessaryOnly_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                30usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PostDispositionWhenNecessaryOnly_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn KmReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_KmReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn KmReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                31usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_KmReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                31usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        CaseSensitiveSearch: UINT32,
        CasePreservedNames: UINT32,
        UnicodeOnDisk: UINT32,
        PersistentAcls: UINT32,
        ReparsePoints: UINT32,
        ReparsePointsAccessCheck: UINT32,
        NamedStreams: UINT32,
        HardLinks: UINT32,
        ExtendedAttributes: UINT32,
        ReadOnlyVolume: UINT32,
        PostCleanupWhenModifiedOnly: UINT32,
        PassQueryDirectoryPattern: UINT32,
        AlwaysUseDoubleBuffering: UINT32,
        PassQueryDirectoryFileName: UINT32,
        FlushAndPurgeOnCleanup: UINT32,
        DeviceControl: UINT32,
        UmFileContextIsUserContext2: UINT32,
        UmFileContextIsFullContext: UINT32,
        UmNoReparsePointsDirCheck: UINT32,
        UmReservedFlags: UINT32,
        AllowOpenInKernelMode: UINT32,
        CasePreservedExtendedAttributes: UINT32,
        WslFeatures: UINT32,
        DirectoryMarkerAsNextOffset: UINT32,
        RejectIrpPriorToTransact0: UINT32,
        SupportsPosixUnlinkRename: UINT32,
        PostDispositionWhenNecessaryOnly: UINT32,
        KmReservedFlags: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let CaseSensitiveSearch: u32 = unsafe { ::std::mem::transmute(CaseSensitiveSearch) };
            CaseSensitiveSearch as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let CasePreservedNames: u32 = unsafe { ::std::mem::transmute(CasePreservedNames) };
            CasePreservedNames as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let UnicodeOnDisk: u32 = unsafe { ::std::mem::transmute(UnicodeOnDisk) };
            UnicodeOnDisk as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let PersistentAcls: u32 = unsafe { ::std::mem::transmute(PersistentAcls) };
            PersistentAcls as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let ReparsePoints: u32 = unsafe { ::std::mem::transmute(ReparsePoints) };
            ReparsePoints as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let ReparsePointsAccessCheck: u32 =
                unsafe { ::std::mem::transmute(ReparsePointsAccessCheck) };
            ReparsePointsAccessCheck as u64
        });
        __bindgen_bitfield_unit.set(6usize, 1u8, {
            let NamedStreams: u32 = unsafe { ::std::mem::transmute(NamedStreams) };
            NamedStreams as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let HardLinks: u32 = unsafe { ::std::mem::transmute(HardLinks) };
            HardLinks as u64
        });
        __bindgen_bitfield_unit.set(8usize, 1u8, {
            let ExtendedAttributes: u32 = unsafe { ::std::mem::transmute(ExtendedAttributes) };
            ExtendedAttributes as u64
        });
        __bindgen_bitfield_unit.set(9usize, 1u8, {
            let ReadOnlyVolume: u32 = unsafe { ::std::mem::transmute(ReadOnlyVolume) };
            ReadOnlyVolume as u64
        });
        __bindgen_bitfield_unit.set(10usize, 1u8, {
            let PostCleanupWhenModifiedOnly: u32 =
                unsafe { ::std::mem::transmute(PostCleanupWhenModifiedOnly) };
            PostCleanupWhenModifiedOnly as u64
        });
        __bindgen_bitfield_unit.set(11usize, 1u8, {
            let PassQueryDirectoryPattern: u32 =
                unsafe { ::std::mem::transmute(PassQueryDirectoryPattern) };
            PassQueryDirectoryPattern as u64
        });
        __bindgen_bitfield_unit.set(12usize, 1u8, {
            let AlwaysUseDoubleBuffering: u32 =
                unsafe { ::std::mem::transmute(AlwaysUseDoubleBuffering) };
            AlwaysUseDoubleBuffering as u64
        });
        __bindgen_bitfield_unit.set(13usize, 1u8, {
            let PassQueryDirectoryFileName: u32 =
                unsafe { ::std::mem::transmute(PassQueryDirectoryFileName) };
            PassQueryDirectoryFileName as u64
        });
        __bindgen_bitfield_unit.set(14usize, 1u8, {
            let FlushAndPurgeOnCleanup: u32 =
                unsafe { ::std::mem::transmute(FlushAndPurgeOnCleanup) };
            FlushAndPurgeOnCleanup as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let DeviceControl: u32 = unsafe { ::std::mem::transmute(DeviceControl) };
            DeviceControl as u64
        });
        __bindgen_bitfield_unit.set(16usize, 1u8, {
            let UmFileContextIsUserContext2: u32 =
                unsafe { ::std::mem::transmute(UmFileContextIsUserContext2) };
            UmFileContextIsUserContext2 as u64
        });
        __bindgen_bitfield_unit.set(17usize, 1u8, {
            let UmFileContextIsFullContext: u32 =
                unsafe { ::std::mem::transmute(UmFileContextIsFullContext) };
            UmFileContextIsFullContext as u64
        });
        __bindgen_bitfield_unit.set(18usize, 1u8, {
            let UmNoReparsePointsDirCheck: u32 =
                unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
            UmNoReparsePointsDirCheck as u64
        });
        __bindgen_bitfield_unit.set(19usize, 5u8, {
            let UmReservedFlags: u32 = unsafe { ::std::mem::transmute(UmReservedFlags) };
            UmReservedFlags as u64
        });
        __bindgen_bitfield_unit.set(24usize, 1u8, {
            let AllowOpenInKernelMode: u32 =
                unsafe { ::std::mem::transmute(AllowOpenInKernelMode) };
            AllowOpenInKernelMode as u64
        });
        __bindgen_bitfield_unit.set(25usize, 1u8, {
            let CasePreservedExtendedAttributes: u32 =
                unsafe { ::std::mem::transmute(CasePreservedExtendedAttributes) };
            CasePreservedExtendedAttributes as u64
        });
        __bindgen_bitfield_unit.set(26usize, 1u8, {
            let WslFeatures: u32 = unsafe { ::std::mem::transmute(WslFeatures) };
            WslFeatures as u64
        });
        __bindgen_bitfield_unit.set(27usize, 1u8, {
            let DirectoryMarkerAsNextOffset: u32 =
                unsafe { ::std::mem::transmute(DirectoryMarkerAsNextOffset) };
            DirectoryMarkerAsNextOffset as u64
        });
        __bindgen_bitfield_unit.set(28usize, 1u8, {
            let RejectIrpPriorToTransact0: u32 =
                unsafe { ::std::mem::transmute(RejectIrpPriorToTransact0) };
            RejectIrpPriorToTransact0 as u64
        });
        __bindgen_bitfield_unit.set(29usize, 1u8, {
            let SupportsPosixUnlinkRename: u32 =
                unsafe { ::std::mem::transmute(SupportsPosixUnlinkRename) };
            SupportsPosixUnlinkRename as u64
        });
        __bindgen_bitfield_unit.set(30usize, 1u8, {
            let PostDispositionWhenNecessaryOnly: u32 =
                unsafe { ::std::mem::transmute(PostDispositionWhenNecessaryOnly) };
            PostDispositionWhenNecessaryOnly as u64
        });
        __bindgen_bitfield_unit.set(31usize, 1u8, {
            let KmReservedFlags: u32 = unsafe { ::std::mem::transmute(KmReservedFlags) };
            KmReservedFlags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSP_FSCTL_VOLUME_PARAMS {
    pub Version: UINT16,
    pub SectorSize: UINT16,
    pub SectorsPerAllocationUnit: UINT16,
    pub MaxComponentLength: UINT16,
    pub VolumeCreationTime: UINT64,
    pub VolumeSerialNumber: UINT32,
    pub TransactTimeout: UINT32,
    pub IrpTimeout: UINT32,
    pub IrpCapacity: UINT32,
    pub FileInfoTimeout: UINT32,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub Prefix: [WCHAR; 192usize],
    pub FileSystemName: [WCHAR; 16usize],
    pub _bitfield_align_2: [u32; 0],
    pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub VolumeInfoTimeout: UINT32,
    pub DirInfoTimeout: UINT32,
    pub SecurityTimeout: UINT32,
    pub StreamInfoTimeout: UINT32,
    pub EaTimeout: UINT32,
    pub FsextControlCode: UINT32,
    pub Reserved32: [UINT32; 1usize],
    pub Reserved64: [UINT64; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_VOLUME_PARAMS"]
        [::std::mem::size_of::<FSP_FSCTL_VOLUME_PARAMS>() - 504usize];
    ["Alignment of FSP_FSCTL_VOLUME_PARAMS"]
        [::std::mem::align_of::<FSP_FSCTL_VOLUME_PARAMS>() - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Version"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Version) - 0usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SectorSize"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SectorSize) - 2usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SectorsPerAllocationUnit"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SectorsPerAllocationUnit) - 4usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::MaxComponentLength"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, MaxComponentLength) - 6usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeCreationTime"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeCreationTime) - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeSerialNumber"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeSerialNumber) - 16usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::TransactTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, TransactTimeout) - 20usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::IrpTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, IrpTimeout) - 24usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::IrpCapacity"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, IrpCapacity) - 28usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FileInfoTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FileInfoTimeout) - 32usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Prefix"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Prefix) - 40usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FileSystemName"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FileSystemName) - 424usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::VolumeInfoTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, VolumeInfoTimeout) - 460usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::DirInfoTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, DirInfoTimeout) - 464usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::SecurityTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, SecurityTimeout) - 468usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::StreamInfoTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, StreamInfoTimeout) - 472usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::EaTimeout"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, EaTimeout) - 476usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::FsextControlCode"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, FsextControlCode) - 480usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Reserved32"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Reserved32) - 484usize];
    ["Offset of field: FSP_FSCTL_VOLUME_PARAMS::Reserved64"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_PARAMS, Reserved64) - 488usize];
};
impl Default for FSP_FSCTL_VOLUME_PARAMS {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl FSP_FSCTL_VOLUME_PARAMS {
    #[inline]
    pub fn CaseSensitiveSearch(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CaseSensitiveSearch(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CaseSensitiveSearch_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CaseSensitiveSearch_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn CasePreservedNames(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CasePreservedNames(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CasePreservedNames_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CasePreservedNames_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UnicodeOnDisk(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UnicodeOnDisk(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UnicodeOnDisk_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UnicodeOnDisk_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PersistentAcls(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PersistentAcls(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PersistentAcls_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                3usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PersistentAcls_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReparsePoints(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReparsePoints(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReparsePoints_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReparsePoints_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReparsePointsAccessCheck(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReparsePointsAccessCheck(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReparsePointsAccessCheck_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                5usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReparsePointsAccessCheck_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn NamedStreams(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_NamedStreams(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn NamedStreams_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                6usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_NamedStreams_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HardLinks(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HardLinks(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HardLinks_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                7usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HardLinks_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ExtendedAttributes(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ExtendedAttributes(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ExtendedAttributes_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                8usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ExtendedAttributes_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReadOnlyVolume(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ReadOnlyVolume(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(9usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReadOnlyVolume_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                9usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReadOnlyVolume_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                9usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PostCleanupWhenModifiedOnly(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PostCleanupWhenModifiedOnly(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(10usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PostCleanupWhenModifiedOnly_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                10usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PostCleanupWhenModifiedOnly_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                10usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PassQueryDirectoryPattern(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PassQueryDirectoryPattern(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(11usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PassQueryDirectoryPattern_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                11usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PassQueryDirectoryPattern_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                11usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn AlwaysUseDoubleBuffering(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_AlwaysUseDoubleBuffering(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(12usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn AlwaysUseDoubleBuffering_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                12usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_AlwaysUseDoubleBuffering_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                12usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PassQueryDirectoryFileName(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PassQueryDirectoryFileName(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(13usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PassQueryDirectoryFileName_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                13usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PassQueryDirectoryFileName_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                13usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn FlushAndPurgeOnCleanup(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_FlushAndPurgeOnCleanup(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(14usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn FlushAndPurgeOnCleanup_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                14usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_FlushAndPurgeOnCleanup_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                14usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DeviceControl(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DeviceControl(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DeviceControl_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                15usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DeviceControl_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmFileContextIsUserContext2(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmFileContextIsUserContext2(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmFileContextIsUserContext2_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                16usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmFileContextIsUserContext2_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmFileContextIsFullContext(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmFileContextIsFullContext(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmFileContextIsFullContext_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                17usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmFileContextIsFullContext_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                17usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmNoReparsePointsDirCheck(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(18usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                18usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                18usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 5u8) as u32) }
    }
    #[inline]
    pub fn set_UmReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(19usize, 5u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                19usize,
                5u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                19usize,
                5u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn AllowOpenInKernelMode(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_AllowOpenInKernelMode(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(24usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn AllowOpenInKernelMode_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                24usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_AllowOpenInKernelMode_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn CasePreservedExtendedAttributes(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CasePreservedExtendedAttributes(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(25usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CasePreservedExtendedAttributes_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                25usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CasePreservedExtendedAttributes_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                25usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn WslFeatures(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_WslFeatures(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(26usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn WslFeatures_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                26usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_WslFeatures_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                26usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DirectoryMarkerAsNextOffset(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DirectoryMarkerAsNextOffset(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DirectoryMarkerAsNextOffset_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                27usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DirectoryMarkerAsNextOffset_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                27usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn RejectIrpPriorToTransact0(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_RejectIrpPriorToTransact0(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn RejectIrpPriorToTransact0_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                28usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_RejectIrpPriorToTransact0_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SupportsPosixUnlinkRename(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SupportsPosixUnlinkRename(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(29usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SupportsPosixUnlinkRename_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                29usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SupportsPosixUnlinkRename_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                29usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PostDispositionWhenNecessaryOnly(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PostDispositionWhenNecessaryOnly(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PostDispositionWhenNecessaryOnly_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                30usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PostDispositionWhenNecessaryOnly_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn KmReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_KmReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn KmReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                31usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_KmReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                31usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        CaseSensitiveSearch: UINT32,
        CasePreservedNames: UINT32,
        UnicodeOnDisk: UINT32,
        PersistentAcls: UINT32,
        ReparsePoints: UINT32,
        ReparsePointsAccessCheck: UINT32,
        NamedStreams: UINT32,
        HardLinks: UINT32,
        ExtendedAttributes: UINT32,
        ReadOnlyVolume: UINT32,
        PostCleanupWhenModifiedOnly: UINT32,
        PassQueryDirectoryPattern: UINT32,
        AlwaysUseDoubleBuffering: UINT32,
        PassQueryDirectoryFileName: UINT32,
        FlushAndPurgeOnCleanup: UINT32,
        DeviceControl: UINT32,
        UmFileContextIsUserContext2: UINT32,
        UmFileContextIsFullContext: UINT32,
        UmNoReparsePointsDirCheck: UINT32,
        UmReservedFlags: UINT32,
        AllowOpenInKernelMode: UINT32,
        CasePreservedExtendedAttributes: UINT32,
        WslFeatures: UINT32,
        DirectoryMarkerAsNextOffset: UINT32,
        RejectIrpPriorToTransact0: UINT32,
        SupportsPosixUnlinkRename: UINT32,
        PostDispositionWhenNecessaryOnly: UINT32,
        KmReservedFlags: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let CaseSensitiveSearch: u32 = unsafe { ::std::mem::transmute(CaseSensitiveSearch) };
            CaseSensitiveSearch as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let CasePreservedNames: u32 = unsafe { ::std::mem::transmute(CasePreservedNames) };
            CasePreservedNames as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let UnicodeOnDisk: u32 = unsafe { ::std::mem::transmute(UnicodeOnDisk) };
            UnicodeOnDisk as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let PersistentAcls: u32 = unsafe { ::std::mem::transmute(PersistentAcls) };
            PersistentAcls as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let ReparsePoints: u32 = unsafe { ::std::mem::transmute(ReparsePoints) };
            ReparsePoints as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let ReparsePointsAccessCheck: u32 =
                unsafe { ::std::mem::transmute(ReparsePointsAccessCheck) };
            ReparsePointsAccessCheck as u64
        });
        __bindgen_bitfield_unit.set(6usize, 1u8, {
            let NamedStreams: u32 = unsafe { ::std::mem::transmute(NamedStreams) };
            NamedStreams as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let HardLinks: u32 = unsafe { ::std::mem::transmute(HardLinks) };
            HardLinks as u64
        });
        __bindgen_bitfield_unit.set(8usize, 1u8, {
            let ExtendedAttributes: u32 = unsafe { ::std::mem::transmute(ExtendedAttributes) };
            ExtendedAttributes as u64
        });
        __bindgen_bitfield_unit.set(9usize, 1u8, {
            let ReadOnlyVolume: u32 = unsafe { ::std::mem::transmute(ReadOnlyVolume) };
            ReadOnlyVolume as u64
        });
        __bindgen_bitfield_unit.set(10usize, 1u8, {
            let PostCleanupWhenModifiedOnly: u32 =
                unsafe { ::std::mem::transmute(PostCleanupWhenModifiedOnly) };
            PostCleanupWhenModifiedOnly as u64
        });
        __bindgen_bitfield_unit.set(11usize, 1u8, {
            let PassQueryDirectoryPattern: u32 =
                unsafe { ::std::mem::transmute(PassQueryDirectoryPattern) };
            PassQueryDirectoryPattern as u64
        });
        __bindgen_bitfield_unit.set(12usize, 1u8, {
            let AlwaysUseDoubleBuffering: u32 =
                unsafe { ::std::mem::transmute(AlwaysUseDoubleBuffering) };
            AlwaysUseDoubleBuffering as u64
        });
        __bindgen_bitfield_unit.set(13usize, 1u8, {
            let PassQueryDirectoryFileName: u32 =
                unsafe { ::std::mem::transmute(PassQueryDirectoryFileName) };
            PassQueryDirectoryFileName as u64
        });
        __bindgen_bitfield_unit.set(14usize, 1u8, {
            let FlushAndPurgeOnCleanup: u32 =
                unsafe { ::std::mem::transmute(FlushAndPurgeOnCleanup) };
            FlushAndPurgeOnCleanup as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let DeviceControl: u32 = unsafe { ::std::mem::transmute(DeviceControl) };
            DeviceControl as u64
        });
        __bindgen_bitfield_unit.set(16usize, 1u8, {
            let UmFileContextIsUserContext2: u32 =
                unsafe { ::std::mem::transmute(UmFileContextIsUserContext2) };
            UmFileContextIsUserContext2 as u64
        });
        __bindgen_bitfield_unit.set(17usize, 1u8, {
            let UmFileContextIsFullContext: u32 =
                unsafe { ::std::mem::transmute(UmFileContextIsFullContext) };
            UmFileContextIsFullContext as u64
        });
        __bindgen_bitfield_unit.set(18usize, 1u8, {
            let UmNoReparsePointsDirCheck: u32 =
                unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
            UmNoReparsePointsDirCheck as u64
        });
        __bindgen_bitfield_unit.set(19usize, 5u8, {
            let UmReservedFlags: u32 = unsafe { ::std::mem::transmute(UmReservedFlags) };
            UmReservedFlags as u64
        });
        __bindgen_bitfield_unit.set(24usize, 1u8, {
            let AllowOpenInKernelMode: u32 =
                unsafe { ::std::mem::transmute(AllowOpenInKernelMode) };
            AllowOpenInKernelMode as u64
        });
        __bindgen_bitfield_unit.set(25usize, 1u8, {
            let CasePreservedExtendedAttributes: u32 =
                unsafe { ::std::mem::transmute(CasePreservedExtendedAttributes) };
            CasePreservedExtendedAttributes as u64
        });
        __bindgen_bitfield_unit.set(26usize, 1u8, {
            let WslFeatures: u32 = unsafe { ::std::mem::transmute(WslFeatures) };
            WslFeatures as u64
        });
        __bindgen_bitfield_unit.set(27usize, 1u8, {
            let DirectoryMarkerAsNextOffset: u32 =
                unsafe { ::std::mem::transmute(DirectoryMarkerAsNextOffset) };
            DirectoryMarkerAsNextOffset as u64
        });
        __bindgen_bitfield_unit.set(28usize, 1u8, {
            let RejectIrpPriorToTransact0: u32 =
                unsafe { ::std::mem::transmute(RejectIrpPriorToTransact0) };
            RejectIrpPriorToTransact0 as u64
        });
        __bindgen_bitfield_unit.set(29usize, 1u8, {
            let SupportsPosixUnlinkRename: u32 =
                unsafe { ::std::mem::transmute(SupportsPosixUnlinkRename) };
            SupportsPosixUnlinkRename as u64
        });
        __bindgen_bitfield_unit.set(30usize, 1u8, {
            let PostDispositionWhenNecessaryOnly: u32 =
                unsafe { ::std::mem::transmute(PostDispositionWhenNecessaryOnly) };
            PostDispositionWhenNecessaryOnly as u64
        });
        __bindgen_bitfield_unit.set(31usize, 1u8, {
            let KmReservedFlags: u32 = unsafe { ::std::mem::transmute(KmReservedFlags) };
            KmReservedFlags as u64
        });
        __bindgen_bitfield_unit
    }
    #[inline]
    pub fn VolumeInfoTimeoutValid(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_VolumeInfoTimeoutValid(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn VolumeInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_VolumeInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DirInfoTimeoutValid(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DirInfoTimeoutValid(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DirInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DirInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SecurityTimeoutValid(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SecurityTimeoutValid(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SecurityTimeoutValid_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                2usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SecurityTimeoutValid_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn StreamInfoTimeoutValid(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_StreamInfoTimeoutValid(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn StreamInfoTimeoutValid_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                3usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_StreamInfoTimeoutValid_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn EaTimeoutValid(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_EaTimeoutValid(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn EaTimeoutValid_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                4usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_EaTimeoutValid_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn KmAdditionalReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_2.get(5usize, 27u8) as u32) }
    }
    #[inline]
    pub fn set_KmAdditionalReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_2.set(5usize, 27u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn KmAdditionalReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_2),
                5usize,
                27u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_KmAdditionalReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_2),
                5usize,
                27u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_2(
        VolumeInfoTimeoutValid: UINT32,
        DirInfoTimeoutValid: UINT32,
        SecurityTimeoutValid: UINT32,
        StreamInfoTimeoutValid: UINT32,
        EaTimeoutValid: UINT32,
        KmAdditionalReservedFlags: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let VolumeInfoTimeoutValid: u32 =
                unsafe { ::std::mem::transmute(VolumeInfoTimeoutValid) };
            VolumeInfoTimeoutValid as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let DirInfoTimeoutValid: u32 = unsafe { ::std::mem::transmute(DirInfoTimeoutValid) };
            DirInfoTimeoutValid as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let SecurityTimeoutValid: u32 = unsafe { ::std::mem::transmute(SecurityTimeoutValid) };
            SecurityTimeoutValid as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let StreamInfoTimeoutValid: u32 =
                unsafe { ::std::mem::transmute(StreamInfoTimeoutValid) };
            StreamInfoTimeoutValid as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let EaTimeoutValid: u32 = unsafe { ::std::mem::transmute(EaTimeoutValid) };
            EaTimeoutValid as u64
        });
        __bindgen_bitfield_unit.set(5usize, 27u8, {
            let KmAdditionalReservedFlags: u32 =
                unsafe { ::std::mem::transmute(KmAdditionalReservedFlags) };
            KmAdditionalReservedFlags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_VOLUME_INFO {
    pub TotalSize: UINT64,
    pub FreeSize: UINT64,
    pub VolumeLabelLength: UINT16,
    pub VolumeLabel: [WCHAR; 32usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_VOLUME_INFO"][::std::mem::size_of::<FSP_FSCTL_VOLUME_INFO>() - 88usize];
    ["Alignment of FSP_FSCTL_VOLUME_INFO"]
        [::std::mem::align_of::<FSP_FSCTL_VOLUME_INFO>() - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_INFO::TotalSize"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, TotalSize) - 0usize];
    ["Offset of field: FSP_FSCTL_VOLUME_INFO::FreeSize"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, FreeSize) - 8usize];
    ["Offset of field: FSP_FSCTL_VOLUME_INFO::VolumeLabelLength"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, VolumeLabelLength) - 16usize];
    ["Offset of field: FSP_FSCTL_VOLUME_INFO::VolumeLabel"]
        [::std::mem::offset_of!(FSP_FSCTL_VOLUME_INFO, VolumeLabel) - 18usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_FILE_INFO {
    pub FileAttributes: UINT32,
    pub ReparseTag: UINT32,
    pub AllocationSize: UINT64,
    pub FileSize: UINT64,
    pub CreationTime: UINT64,
    pub LastAccessTime: UINT64,
    pub LastWriteTime: UINT64,
    pub ChangeTime: UINT64,
    pub IndexNumber: UINT64,
    pub HardLinks: UINT32,
    pub EaSize: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_FILE_INFO"][::std::mem::size_of::<FSP_FSCTL_FILE_INFO>() - 72usize];
    ["Alignment of FSP_FSCTL_FILE_INFO"][::std::mem::align_of::<FSP_FSCTL_FILE_INFO>() - 8usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::FileAttributes"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, FileAttributes) - 0usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::ReparseTag"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, ReparseTag) - 4usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::AllocationSize"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, AllocationSize) - 8usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::FileSize"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, FileSize) - 16usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::CreationTime"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, CreationTime) - 24usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::LastAccessTime"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, LastAccessTime) - 32usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::LastWriteTime"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, LastWriteTime) - 40usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::ChangeTime"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, ChangeTime) - 48usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::IndexNumber"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, IndexNumber) - 56usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::HardLinks"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, HardLinks) - 64usize];
    ["Offset of field: FSP_FSCTL_FILE_INFO::EaSize"]
        [::std::mem::offset_of!(FSP_FSCTL_FILE_INFO, EaSize) - 68usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSP_FSCTL_OPEN_FILE_INFO {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
    pub NormalizedName: PWSTR,
    pub NormalizedNameSize: UINT16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_OPEN_FILE_INFO"]
        [::std::mem::size_of::<FSP_FSCTL_OPEN_FILE_INFO>() - 88usize];
    ["Alignment of FSP_FSCTL_OPEN_FILE_INFO"]
        [::std::mem::align_of::<FSP_FSCTL_OPEN_FILE_INFO>() - 8usize];
    ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::FileInfo"]
        [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, FileInfo) - 0usize];
    ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::NormalizedName"]
        [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, NormalizedName) - 72usize];
    ["Offset of field: FSP_FSCTL_OPEN_FILE_INFO::NormalizedNameSize"]
        [::std::mem::offset_of!(FSP_FSCTL_OPEN_FILE_INFO, NormalizedNameSize) - 80usize];
};
impl Default for FSP_FSCTL_OPEN_FILE_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct FSP_FSCTL_DIR_INFO {
    pub Size: UINT16,
    pub FileInfo: FSP_FSCTL_FILE_INFO,
    pub __bindgen_anon_1: FSP_FSCTL_DIR_INFO__bindgen_ty_1,
    pub FileNameBuf: __IncompleteArrayField<WCHAR>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_DIR_INFO__bindgen_ty_1 {
    pub NextOffset: UINT64,
    pub Padding: [UINT8; 24usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_DIR_INFO__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_DIR_INFO__bindgen_ty_1>() - 24usize];
    ["Alignment of FSP_FSCTL_DIR_INFO__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_DIR_INFO__bindgen_ty_1>() - 8usize];
    ["Offset of field: FSP_FSCTL_DIR_INFO__bindgen_ty_1::NextOffset"]
        [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO__bindgen_ty_1, NextOffset) - 0usize];
    ["Offset of field: FSP_FSCTL_DIR_INFO__bindgen_ty_1::Padding"]
        [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO__bindgen_ty_1, Padding) - 0usize];
};
impl Default for FSP_FSCTL_DIR_INFO__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_DIR_INFO"][::std::mem::size_of::<FSP_FSCTL_DIR_INFO>() - 104usize];
    ["Alignment of FSP_FSCTL_DIR_INFO"][::std::mem::align_of::<FSP_FSCTL_DIR_INFO>() - 8usize];
    ["Offset of field: FSP_FSCTL_DIR_INFO::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, Size) - 0usize];
    ["Offset of field: FSP_FSCTL_DIR_INFO::FileInfo"]
        [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, FileInfo) - 8usize];
    ["Offset of field: FSP_FSCTL_DIR_INFO::FileNameBuf"]
        [::std::mem::offset_of!(FSP_FSCTL_DIR_INFO, FileNameBuf) - 104usize];
};
impl Default for FSP_FSCTL_DIR_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct FSP_FSCTL_STREAM_INFO {
    pub Size: UINT16,
    pub StreamSize: UINT64,
    pub StreamAllocationSize: UINT64,
    pub StreamNameBuf: __IncompleteArrayField<WCHAR>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_STREAM_INFO"][::std::mem::size_of::<FSP_FSCTL_STREAM_INFO>() - 24usize];
    ["Alignment of FSP_FSCTL_STREAM_INFO"]
        [::std::mem::align_of::<FSP_FSCTL_STREAM_INFO>() - 8usize];
    ["Offset of field: FSP_FSCTL_STREAM_INFO::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, Size) - 0usize];
    ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamSize"]
        [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamSize) - 8usize];
    ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamAllocationSize"]
        [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamAllocationSize) - 16usize];
    ["Offset of field: FSP_FSCTL_STREAM_INFO::StreamNameBuf"]
        [::std::mem::offset_of!(FSP_FSCTL_STREAM_INFO, StreamNameBuf) - 24usize];
};
#[repr(C)]
#[derive(Debug, Default)]
pub struct FSP_FSCTL_NOTIFY_INFO {
    pub Size: UINT16,
    pub Filter: UINT32,
    pub Action: UINT32,
    pub FileNameBuf: __IncompleteArrayField<WCHAR>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_NOTIFY_INFO"][::std::mem::size_of::<FSP_FSCTL_NOTIFY_INFO>() - 12usize];
    ["Alignment of FSP_FSCTL_NOTIFY_INFO"]
        [::std::mem::align_of::<FSP_FSCTL_NOTIFY_INFO>() - 4usize];
    ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Size) - 0usize];
    ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Filter"]
        [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Filter) - 4usize];
    ["Offset of field: FSP_FSCTL_NOTIFY_INFO::Action"]
        [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, Action) - 8usize];
    ["Offset of field: FSP_FSCTL_NOTIFY_INFO::FileNameBuf"]
        [::std::mem::offset_of!(FSP_FSCTL_NOTIFY_INFO, FileNameBuf) - 12usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_FULL_CONTEXT {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_FULL_CONTEXT"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_FULL_CONTEXT>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_FULL_CONTEXT"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_FULL_CONTEXT>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_FULL_CONTEXT::UserContext"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_FULL_CONTEXT, UserContext) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_FULL_CONTEXT::UserContext2"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_FULL_CONTEXT, UserContext2) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_BUF {
    pub Offset: UINT16,
    pub Size: UINT16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_BUF"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_BUF>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_BUF"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_BUF>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_BUF::Offset"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_BUF, Offset) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_BUF::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_BUF, Size) - 2usize];
};
#[repr(C)]
pub struct FSP_FSCTL_TRANSACT_REQ {
    pub Version: UINT16,
    pub Size: UINT16,
    pub Kind: UINT32,
    pub Hint: UINT64,
    pub Req: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
    pub FileName: FSP_FSCTL_TRANSACT_BUF,
    pub __bindgen_padding_0: [u8; 4usize],
    pub Buffer: __IncompleteArrayField<UINT8>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1 {
    pub Create: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
    pub Overwrite: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
    pub Cleanup: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
    pub Close: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
    pub Read: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
    pub Write: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
    pub QueryInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
    pub SetInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
    pub QueryEa: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
    pub SetEa: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
    pub FlushBuffers: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
    pub SetVolumeInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
    pub QueryDirectory: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
    pub FileSystemControl: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
    pub DeviceControl: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
    pub QuerySecurity: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
    pub SetSecurity: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
    pub QueryStreamInformation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1 {
    pub CreateOptions: UINT32,
    pub FileAttributes: UINT32,
    pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
    pub AllocationSize: UINT64,
    pub AccessToken: UINT64,
    pub DesiredAccess: UINT32,
    pub GrantedAccess: UINT32,
    pub ShareAccess: UINT32,
    pub Ea: FSP_FSCTL_TRANSACT_BUF,
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
    pub NamedStream: UINT16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1>() - 64usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::CreateOptions"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        CreateOptions
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::FileAttributes"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        FileAttributes
    )
        - 4usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::SecurityDescriptor"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        SecurityDescriptor
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::AllocationSize"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        AllocationSize
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::AccessToken"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        AccessToken
    )
        - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::DesiredAccess"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        DesiredAccess
    )
        - 32usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::GrantedAccess"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        GrantedAccess
    )
        - 36usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::ShareAccess"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        ShareAccess
    )
        - 40usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::Ea"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1, Ea) - 44usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1::NamedStream"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1,
        NamedStream
    )
        - 56usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn UserMode(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_UserMode(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UserMode_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_UserMode_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HasTraversePrivilege(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HasTraversePrivilege(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HasTraversePrivilege_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HasTraversePrivilege_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HasBackupPrivilege(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HasBackupPrivilege(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HasBackupPrivilege_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HasBackupPrivilege_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HasRestorePrivilege(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HasRestorePrivilege(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HasRestorePrivilege_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                3usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HasRestorePrivilege_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn OpenTargetDirectory(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_OpenTargetDirectory(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn OpenTargetDirectory_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_OpenTargetDirectory_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn CaseSensitive(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CaseSensitive(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CaseSensitive_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                5usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CaseSensitive_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HasTrailingBackslash(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HasTrailingBackslash(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(6usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HasTrailingBackslash_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                6usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HasTrailingBackslash_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn AcceptsSecurityDescriptor(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_AcceptsSecurityDescriptor(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn AcceptsSecurityDescriptor_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                7usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_AcceptsSecurityDescriptor_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                7usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn EaIsReparsePoint(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_EaIsReparsePoint(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn EaIsReparsePoint_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                8usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_EaIsReparsePoint_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn ReservedFlags(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 24u8) as u32) }
    }
    #[inline]
    pub fn set_ReservedFlags(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(32usize, 24u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ReservedFlags_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 7usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                32usize,
                24u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ReservedFlags_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 7usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                32usize,
                24u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        UserMode: UINT32,
        HasTraversePrivilege: UINT32,
        HasBackupPrivilege: UINT32,
        HasRestorePrivilege: UINT32,
        OpenTargetDirectory: UINT32,
        CaseSensitive: UINT32,
        HasTrailingBackslash: UINT32,
        AcceptsSecurityDescriptor: UINT32,
        EaIsReparsePoint: UINT32,
        ReservedFlags: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let UserMode: u32 = unsafe { ::std::mem::transmute(UserMode) };
            UserMode as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let HasTraversePrivilege: u32 = unsafe { ::std::mem::transmute(HasTraversePrivilege) };
            HasTraversePrivilege as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let HasBackupPrivilege: u32 = unsafe { ::std::mem::transmute(HasBackupPrivilege) };
            HasBackupPrivilege as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let HasRestorePrivilege: u32 = unsafe { ::std::mem::transmute(HasRestorePrivilege) };
            HasRestorePrivilege as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let OpenTargetDirectory: u32 = unsafe { ::std::mem::transmute(OpenTargetDirectory) };
            OpenTargetDirectory as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let CaseSensitive: u32 = unsafe { ::std::mem::transmute(CaseSensitive) };
            CaseSensitive as u64
        });
        __bindgen_bitfield_unit.set(6usize, 1u8, {
            let HasTrailingBackslash: u32 = unsafe { ::std::mem::transmute(HasTrailingBackslash) };
            HasTrailingBackslash as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let AcceptsSecurityDescriptor: u32 =
                unsafe { ::std::mem::transmute(AcceptsSecurityDescriptor) };
            AcceptsSecurityDescriptor as u64
        });
        __bindgen_bitfield_unit.set(8usize, 1u8, {
            let EaIsReparsePoint: u32 = unsafe { ::std::mem::transmute(EaIsReparsePoint) };
            EaIsReparsePoint as u64
        });
        __bindgen_bitfield_unit.set(32usize, 24u8, {
            let ReservedFlags: u32 = unsafe { ::std::mem::transmute(ReservedFlags) };
            ReservedFlags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub FileAttributes: UINT32,
    pub AllocationSize: UINT64,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: u16,
    pub Ea: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2>() - 40usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::FileAttributes"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
        FileAttributes
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::AllocationSize"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2,
        AllocationSize
    )
        - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2::Ea"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2, Ea) - 36usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_2 {
    #[inline]
    pub fn Supersede(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_Supersede(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Supersede_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Supersede_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(Supersede: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let Supersede: u32 = unsafe { ::std::mem::transmute(Supersede) };
            Supersede as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3>() - 24usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3,
        UserContext2
    )
        - 8usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_3 {
    #[inline]
    pub fn Delete(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_Delete(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Delete_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Delete_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetAllocationSize(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SetAllocationSize(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetAllocationSize_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetAllocationSize_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetArchiveBit(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SetArchiveBit(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetArchiveBit_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetArchiveBit_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetLastAccessTime(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SetLastAccessTime(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetLastAccessTime_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                3usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetLastAccessTime_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetLastWriteTime(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SetLastWriteTime(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetLastWriteTime_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetLastWriteTime_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetChangeTime(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_SetChangeTime(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetChangeTime_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                5usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetChangeTime_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                5usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        Delete: UINT32,
        SetAllocationSize: UINT32,
        SetArchiveBit: UINT32,
        SetLastAccessTime: UINT32,
        SetLastWriteTime: UINT32,
        SetChangeTime: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let Delete: u32 = unsafe { ::std::mem::transmute(Delete) };
            Delete as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let SetAllocationSize: u32 = unsafe { ::std::mem::transmute(SetAllocationSize) };
            SetAllocationSize as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let SetArchiveBit: u32 = unsafe { ::std::mem::transmute(SetArchiveBit) };
            SetArchiveBit as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let SetLastAccessTime: u32 = unsafe { ::std::mem::transmute(SetLastAccessTime) };
            SetLastAccessTime as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let SetLastWriteTime: u32 = unsafe { ::std::mem::transmute(SetLastWriteTime) };
            SetLastWriteTime as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let SetChangeTime: u32 = unsafe { ::std::mem::transmute(SetChangeTime) };
            SetChangeTime as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_4,
        UserContext2
    )
        - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub Address: UINT64,
    pub Offset: UINT64,
    pub Length: UINT32,
    pub Key: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5>() - 40usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Address"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
        Address
    ) - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Offset"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
        Offset
    ) - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Length"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5,
        Length
    ) - 32usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5::Key"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_5, Key) - 36usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub Address: UINT64,
    pub Offset: UINT64,
    pub Length: UINT32,
    pub Key: UINT32,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6>() - 48usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Address"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
        Address
    ) - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Offset"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
        Offset
    ) - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Length"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6,
        Length
    ) - 32usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6::Key"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6, Key) - 36usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_6 {
    #[inline]
    pub fn ConstrainedIo(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_ConstrainedIo(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn ConstrainedIo_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_ConstrainedIo_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(ConstrainedIo: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let ConstrainedIo: u32 = unsafe { ::std::mem::transmute(ConstrainedIo) };
            ConstrainedIo as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_7,
        UserContext2
    )
        - 8usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub FileInformationClass: UINT32,
    pub Info: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
    pub Allocation: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
    pub Basic: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
    pub Disposition: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
    pub DispositionEx:
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
    pub EndOfFile: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
    pub Rename: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
    pub RenameEx: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1 {
    pub AllocationSize: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
        >() - 8usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
        >() - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1::AllocationSize",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_1,
        AllocationSize
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2 {
    pub FileAttributes: UINT32,
    pub CreationTime: UINT64,
    pub LastAccessTime: UINT64,
    pub LastWriteTime: UINT64,
    pub ChangeTime: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        >() - 40usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        >() - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::FileAttributes",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        FileAttributes
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::CreationTime",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        CreationTime
    ) - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::LastAccessTime",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        LastAccessTime
    ) - 16usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::LastWriteTime",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        LastWriteTime
    ) - 24usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2::ChangeTime",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_2,
        ChangeTime
    ) - 32usize];
};
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3 {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
        >() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3,
        >() - 4usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_3 {
    #[inline]
    pub fn Delete(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_Delete(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Delete_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Delete_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(Delete: UINT32) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let Delete: u32 = unsafe { ::std::mem::transmute(Delete) };
            Delete as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4 {
    pub Flags: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
        >() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
        >() - 4usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4::Flags",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_4,
        Flags
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5 {
    pub FileSize: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
        >() - 8usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
        >() - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5::FileSize",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_5,
        FileSize
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6 {
    pub NewFileName: FSP_FSCTL_TRANSACT_BUF,
    pub AccessToken: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
        >() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
        >() - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6::NewFileName",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
        NewFileName
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6::AccessToken",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_6,
        AccessToken
    ) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7 {
    pub NewFileName: FSP_FSCTL_TRANSACT_BUF,
    pub AccessToken: UINT64,
    pub Flags: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
        >() - 24usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7"]
        [::std::mem::align_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
        >() - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::NewFileName",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
        NewFileName
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::AccessToken",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
        AccessToken
    ) - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7::Flags",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1__bindgen_ty_7,
        Flags
    ) - 16usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1"][::std::mem::size_of::<
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
    >() - 40usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1>(
        ) - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Allocation",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        Allocation
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Basic"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        Basic
    )
        - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Disposition",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        Disposition
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::DispositionEx",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        DispositionEx
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::EndOfFile",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        EndOfFile
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::Rename"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
        Rename
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1::RenameEx"]
        [::std::mem::offset_of!(
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1,
            RenameEx
        ) - 0usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8>() - 64usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::FileInformationClass"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
        FileInformationClass
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8::Info"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8,
        Info
    ) - 24usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_8 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_9,
        UserContext2
    )
        - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub Ea: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10>() - 24usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10::Ea"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_10, Ea) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_11,
        UserContext2
    )
        - 8usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12 {
    pub FsInformationClass: UINT32,
    pub Info: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
    pub Label: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1 {
    pub VolumeLabel: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::size_of::<
            FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
        >() - 4usize];
    [
        "Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
    >() - 2usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1::VolumeLabel",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1__bindgen_ty_1,
        VolumeLabel
    ) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1>(
        ) - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1>(
        ) - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1::Label"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1,
        Label
    )
        - 0usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12>() - 8usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12>() - 4usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12::FsInformationClass"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
        FsInformationClass
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12::Info"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12,
        Info
    ) - 4usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_12 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub Address: UINT64,
    pub Length: UINT32,
    pub Pattern: FSP_FSCTL_TRANSACT_BUF,
    pub Marker: FSP_FSCTL_TRANSACT_BUF,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13>() - 40usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Address"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        Address
    ) - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Length"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        Length
    ) - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Pattern"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        Pattern
    ) - 28usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13::Marker"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13,
        Marker
    ) - 32usize];
};
impl FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_13 {
    #[inline]
    pub fn CaseSensitive(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_CaseSensitive(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn CaseSensitive_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_CaseSensitive_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn PatternIsFileName(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_PatternIsFileName(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn PatternIsFileName_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_PatternIsFileName_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        CaseSensitive: UINT32,
        PatternIsFileName: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let CaseSensitive: u32 = unsafe { ::std::mem::transmute(CaseSensitive) };
            CaseSensitive as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let PatternIsFileName: u32 = unsafe { ::std::mem::transmute(PatternIsFileName) };
            PatternIsFileName as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub FsControlCode: UINT32,
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
    pub TargetOnFileSystem: UINT16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14>() - 32usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::FsControlCode"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
        FsControlCode
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
        Buffer
    ) - 20usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14::TargetOnFileSystem"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_14,
        TargetOnFileSystem
    )
        - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub IoControlCode: UINT32,
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
    pub OutputLength: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15>() - 32usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::IoControlCode"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
        IoControlCode
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
        Buffer
    ) - 20usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15::OutputLength"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_15,
        OutputLength
    )
        - 24usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_16,
        UserContext2
    )
        - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub SecurityInformation: UINT32,
    pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17>() - 24usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
        UserContext2
    )
        - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::SecurityInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
        SecurityInformation
    )
        - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17::SecurityDescriptor"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_17,
        SecurityDescriptor
    )
        - 20usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18>() - 16usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18::UserContext"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
        UserContext
    )
        - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18::UserContext2"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1__bindgen_ty_18,
        UserContext2
    )
        - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1>() - 64usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Create"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Create) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Overwrite"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Overwrite) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Cleanup"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Cleanup) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Close"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Close) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Read"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Read) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::Write"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, Write) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryInformation"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryInformation) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetInformation"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetInformation) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryEa"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryEa) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetEa"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetEa) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::FlushBuffers"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, FlushBuffers) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetVolumeInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
        SetVolumeInformation
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryDirectory"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QueryDirectory) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::FileSystemControl"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, FileSystemControl) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::DeviceControl"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, DeviceControl) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QuerySecurity"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, QuerySecurity) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::SetSecurity"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1, SetSecurity) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1::QueryStreamInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1,
        QueryStreamInformation
    ) - 0usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_REQ"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_REQ>() - 88usize];
    ["Alignment of FSP_FSCTL_TRANSACT_REQ"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_REQ>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Version"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Version) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Size) - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Kind"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Kind) - 4usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Hint"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Hint) - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Req"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Req) - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::FileName"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, FileName) - 80usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_REQ::Buffer"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_REQ, Buffer) - 88usize];
};
impl Default for FSP_FSCTL_TRANSACT_REQ {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct FSP_FSCTL_TRANSACT_RSP {
    pub Version: UINT16,
    pub Size: UINT16,
    pub Kind: UINT32,
    pub Hint: UINT64,
    pub IoStatus: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1,
    pub Rsp: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
    pub Buffer: __IncompleteArrayField<UINT8>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1 {
    pub Information: UINT32,
    pub Status: UINT32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1>() - 8usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1>() - 4usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1::Information"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1, Information) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1::Status"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_1, Status) - 4usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2 {
    pub Create: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
    pub Overwrite: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2,
    pub Write: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3,
    pub QueryInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4,
    pub SetInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5,
    pub QueryEa: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6,
    pub SetEa: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7,
    pub FlushBuffers: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8,
    pub QueryVolumeInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9,
    pub SetVolumeInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10,
    pub FileSystemControl: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11,
    pub DeviceControl: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12,
    pub QuerySecurity: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13,
    pub SetSecurity: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14,
    pub QueryStreamInformation: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1 {
    pub Opened: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
    pub Reparse: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
    pub UserContext: UINT64,
    pub UserContext2: UINT64,
    pub GrantedAccess: UINT32,
    pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
    pub FileInfo: FSP_FSCTL_FILE_INFO,
    pub FileName: FSP_FSCTL_TRANSACT_BUF,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: [u8; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
    >()
        - 104usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1>(
        ) - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::UserContext",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
        UserContext
    ) - 0usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::UserContext2",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
        UserContext2
    ) - 8usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::GrantedAccess",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
        GrantedAccess
    ) - 16usize];
    [
        "Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::SecurityDescriptor",
    ][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
        SecurityDescriptor
    ) - 20usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::FileInfo"]
        [::std::mem::offset_of!(
            FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
            FileInfo
        ) - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::FileName"]
        [::std::mem::offset_of!(
            FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
            FileName
        ) - 96usize];
};
impl FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn DisableCache(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_DisableCache(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DisableCache_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DisableCache_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn HasSecurityDescriptor(&self) -> UINT32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_HasSecurityDescriptor(&mut self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn HasSecurityDescriptor_raw(this: *const Self) -> UINT32 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_HasSecurityDescriptor_raw(this: *mut Self, val: UINT32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        DisableCache: UINT32,
        HasSecurityDescriptor: UINT32,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let DisableCache: u32 = unsafe { ::std::mem::transmute(DisableCache) };
            DisableCache as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let HasSecurityDescriptor: u32 =
                unsafe { ::std::mem::transmute(HasSecurityDescriptor) };
            HasSecurityDescriptor as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2 {
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2"][::std::mem::size_of::<
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
    >() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2>(
        ) - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1__bindgen_ty_2,
        Buffer
    )
        - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1>() - 104usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1::Opened"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
        Opened
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1::Reparse"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1,
        Reparse
    ) - 0usize];
};
impl Default for FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2>() - 72usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_2,
        FileInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3>() - 72usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_3,
        FileInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4>() - 72usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_4,
        FileInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5>() - 72usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_5,
        FileInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6 {
    pub Ea: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6::Ea"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_6, Ea) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
    pub Ea: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7>() - 80usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7,
        FileInfo
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7::Ea"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_7, Ea) - 72usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8 {
    pub FileInfo: FSP_FSCTL_FILE_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8>() - 72usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8::FileInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_8,
        FileInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9 {
    pub VolumeInfo: FSP_FSCTL_VOLUME_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9>() - 88usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9::VolumeInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_9,
        VolumeInfo
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10 {
    pub VolumeInfo: FSP_FSCTL_VOLUME_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10>() - 88usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10::VolumeInfo"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_10,
        VolumeInfo
    )
        - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11 {
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_11,
        Buffer
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12 {
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_12,
        Buffer
    ) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13 {
    pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13::SecurityDescriptor"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_13,
        SecurityDescriptor
    )
        - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14 {
    pub SecurityDescriptor: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14::SecurityDescriptor"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_14,
        SecurityDescriptor
    )
        - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15 {
    pub Buffer: FSP_FSCTL_TRANSACT_BUF,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15>() - 4usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15>() - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15::Buffer"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2__bindgen_ty_15,
        Buffer
    ) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2"]
        [::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2>() - 104usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Create"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Create) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Overwrite"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Overwrite) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::Write"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, Write) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryInformation"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QueryInformation) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetInformation"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetInformation) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryEa"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QueryEa) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetEa"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetEa) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::FlushBuffers"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, FlushBuffers) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryVolumeInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
        QueryVolumeInformation
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetVolumeInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
        SetVolumeInformation
    ) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::FileSystemControl"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, FileSystemControl) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::DeviceControl"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, DeviceControl) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QuerySecurity"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, QuerySecurity) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::SetSecurity"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2, SetSecurity) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2::QueryStreamInformation"][::std::mem::offset_of!(
        FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2,
        QueryStreamInformation
    ) - 0usize];
};
impl Default for FSP_FSCTL_TRANSACT_RSP__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_FSCTL_TRANSACT_RSP"][::std::mem::size_of::<FSP_FSCTL_TRANSACT_RSP>() - 128usize];
    ["Alignment of FSP_FSCTL_TRANSACT_RSP"]
        [::std::mem::align_of::<FSP_FSCTL_TRANSACT_RSP>() - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Version"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Version) - 0usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Size"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Size) - 2usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Kind"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Kind) - 4usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Hint"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Hint) - 8usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::IoStatus"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, IoStatus) - 16usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Rsp"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Rsp) - 24usize];
    ["Offset of field: FSP_FSCTL_TRANSACT_RSP::Buffer"]
        [::std::mem::offset_of!(FSP_FSCTL_TRANSACT_RSP, Buffer) - 128usize];
};
impl Default for FSP_FSCTL_TRANSACT_RSP {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn FspFsctlCreateVolume(
        DevicePath: PWSTR,
        VolumeParams: *const FSP_FSCTL_VOLUME_PARAMS,
        VolumeNameBuf: PWCHAR,
        VolumeNameSize: SIZE_T,
        PVolumeHandle: PHANDLE,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlMakeMountdev(
        VolumeHandle: HANDLE,
        Persistent: BOOLEAN,
        UniqueId: *mut GUID,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlUseMountmgr(VolumeHandle: HANDLE, MountPoint: PWSTR) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlTransact(
        VolumeHandle: HANDLE,
        ResponseBuf: PVOID,
        ResponseBufSize: SIZE_T,
        RequestBuf: PVOID,
        PRequestBufSize: *mut SIZE_T,
        Batch: BOOLEAN,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlStop(VolumeHandle: HANDLE) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlStop0(VolumeHandle: HANDLE) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlNotify(
        VolumeHandle: HANDLE,
        NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
        Size: SIZE_T,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlGetVolumeList(
        DevicePath: PWSTR,
        VolumeListBuf: PWCHAR,
        PVolumeListSize: PSIZE_T,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlPreflight(DevicePath: PWSTR) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlServiceVersion(PVersion: PUINT32) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlStartService() -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlStopService() -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFsctlEnumServices(
        EnumFn: ::std::option::Option<
            unsafe extern "C" fn(Context: PVOID, ServiceName: PWSTR, Running: BOOLEAN),
        >,
        Context: PVOID,
    ) -> NTSTATUS;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSP_MOUNT_DESC {
    pub VolumeHandle: HANDLE,
    pub VolumeName: PWSTR,
    pub Security: PSECURITY_DESCRIPTOR,
    pub Reserved: UINT64,
    pub MountPoint: PWSTR,
    pub MountHandle: HANDLE,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FSP_MOUNT_DESC"][::std::mem::size_of::<FSP_MOUNT_DESC>() - 48usize];
    ["Alignment of FSP_MOUNT_DESC"][::std::mem::align_of::<FSP_MOUNT_DESC>() - 8usize];
    ["Offset of field: FSP_MOUNT_DESC::VolumeHandle"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, VolumeHandle) - 0usize];
    ["Offset of field: FSP_MOUNT_DESC::VolumeName"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, VolumeName) - 8usize];
    ["Offset of field: FSP_MOUNT_DESC::Security"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, Security) - 16usize];
    ["Offset of field: FSP_MOUNT_DESC::Reserved"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, Reserved) - 24usize];
    ["Offset of field: FSP_MOUNT_DESC::MountPoint"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, MountPoint) - 32usize];
    ["Offset of field: FSP_MOUNT_DESC::MountHandle"]
        [::std::mem::offset_of!(FSP_MOUNT_DESC, MountHandle) - 40usize];
};
impl Default for FSP_MOUNT_DESC {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub fn FspMountSet(Desc: *mut FSP_MOUNT_DESC) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspMountRemove(Desc: *mut FSP_MOUNT_DESC) -> NTSTATUS;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _FILE_FULL_EA_INFORMATION {
    pub NextEntryOffset: ULONG,
    pub Flags: UCHAR,
    pub EaNameLength: UCHAR,
    pub EaValueLength: USHORT,
    pub EaName: [CHAR; 1usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FILE_FULL_EA_INFORMATION"]
        [::std::mem::size_of::<_FILE_FULL_EA_INFORMATION>() - 12usize];
    ["Alignment of _FILE_FULL_EA_INFORMATION"]
        [::std::mem::align_of::<_FILE_FULL_EA_INFORMATION>() - 4usize];
    ["Offset of field: _FILE_FULL_EA_INFORMATION::NextEntryOffset"]
        [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, NextEntryOffset) - 0usize];
    ["Offset of field: _FILE_FULL_EA_INFORMATION::Flags"]
        [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, Flags) - 4usize];
    ["Offset of field: _FILE_FULL_EA_INFORMATION::EaNameLength"]
        [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaNameLength) - 5usize];
    ["Offset of field: _FILE_FULL_EA_INFORMATION::EaValueLength"]
        [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaValueLength) - 6usize];
    ["Offset of field: _FILE_FULL_EA_INFORMATION::EaName"]
        [::std::mem::offset_of!(_FILE_FULL_EA_INFORMATION, EaName) - 8usize];
};
pub type PFILE_FULL_EA_INFORMATION = *mut _FILE_FULL_EA_INFORMATION;
#[doc = " @group File System\n\n A user mode file system is a program that uses the WinFsp API to expose a file system to\n Windows. The user mode file system must implement the operations in FSP_FILE_SYSTEM_INTERFACE,\n create a file system object using FspFileSystemCreate and start its dispatcher using\n FspFileSystemStartDispatcher. At that point it will start receiving file system requests on the\n FSP_FILE_SYSTEM_INTERFACE operations."]
pub type FSP_FILE_SYSTEM = _FSP_FILE_SYSTEM;
pub type FSP_FILE_SYSTEM_OPERATION_GUARD = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut FSP_FILE_SYSTEM,
        arg2: *mut FSP_FSCTL_TRANSACT_REQ,
        arg3: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS,
>;
pub type FSP_FILE_SYSTEM_OPERATION = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut FSP_FILE_SYSTEM,
        arg2: *mut FSP_FSCTL_TRANSACT_REQ,
        arg3: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS,
>;
pub const FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FINE:
    FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = 0;
pub const FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY_COARSE : FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = 1 ;
#[doc = " User mode file system locking strategy.\n\n Two concurrency models are provided:\n\n 1. A fine-grained concurrency model where file system NAMESPACE accesses\n are guarded using an exclusive-shared (read-write) lock. File I/O is not\n guarded and concurrent reads/writes/etc. are possible. [Note that the FSD\n will still apply an exclusive-shared lock PER INDIVIDUAL FILE, but it will\n not limit I/O operations for different files.]\n\n The fine-grained concurrency model applies the exclusive-shared lock as\n follows:\n <ul>\n <li>EXCL: SetVolumeLabel, Flush(Volume),\n Create, Cleanup(Delete), SetInformation(Rename)</li>\n <li>SHRD: GetVolumeInfo, Open, SetInformation(Disposition), ReadDirectory</li>\n <li>NONE: all other operations</li>\n </ul>\n\n 2. A coarse-grained concurrency model where all file system accesses are\n guarded by a mutually exclusive lock.\n\n @see FspFileSystemSetOperationGuardStrategy"]
pub type FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY = ::std::os::raw::c_int;
pub const FspCleanupDelete: _bindgen_ty_6 = 1;
pub const FspCleanupSetAllocationSize: _bindgen_ty_6 = 2;
pub const FspCleanupSetArchiveBit: _bindgen_ty_6 = 16;
pub const FspCleanupSetLastAccessTime: _bindgen_ty_6 = 32;
pub const FspCleanupSetLastWriteTime: _bindgen_ty_6 = 64;
pub const FspCleanupSetChangeTime: _bindgen_ty_6 = 128;
pub type _bindgen_ty_6 = ::std::os::raw::c_int;
#[doc = " @class FSP_FILE_SYSTEM\n File system interface.\n\n The operations in this interface must be implemented by the user mode\n file system. Not all operations need be implemented. For example,\n a user mode file system that does not wish to support reparse points,\n need not implement the reparse point operations.\n\n Most of the operations accept a FileContext parameter. This parameter\n has different meanings depending on the value of the FSP_FSCTL_VOLUME_PARAMS\n flags UmFileContextIsUserContext2 and UmFileContextIsFullContext.\n\n There are three cases to consider:\n <ul>\n <li>When both of these flags are unset (default), the FileContext parameter\n represents the file node. The file node is a void pointer (or an integer\n that can fit in a pointer) that is used to uniquely identify an open file.\n Opening the same file name should always yield the same file node value\n for as long as the file with that name remains open anywhere in the system.\n </li>\n <li>When the UmFileContextIsUserContext2 is set, the FileContext parameter\n represents the file descriptor. The file descriptor is a void pointer (or\n an integer that can fit in a pointer) that is used to identify an open\n instance of a file. Opening the same file name may yield a different file\n descriptor.\n </li>\n <li>When the UmFileContextIsFullContext is set, the FileContext parameter\n is a pointer to a FSP_FSCTL_TRANSACT_FULL_CONTEXT. This allows a user mode\n file system to access the low-level UserContext and UserContext2 values.\n The UserContext is used to store the file node and the UserContext2 is\n used to store the file descriptor for an open file.\n </li>\n </ul>"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _FSP_FILE_SYSTEM_INTERFACE {
    #[doc = " Get volume information.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param VolumeInfo [out]\n     Pointer to a structure that will receive the volume information on successful return\n     from this call.\n @return\n     STATUS_SUCCESS or error code."]
    pub GetVolumeInfo: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            VolumeInfo: *mut FSP_FSCTL_VOLUME_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Set volume label.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param VolumeLabel\n     The new label for the volume.\n @param VolumeInfo [out]\n     Pointer to a structure that will receive the volume information on successful return\n     from this call.\n @return\n     STATUS_SUCCESS or error code."]
    pub SetVolumeLabelW: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            VolumeLabel: PWSTR,
            VolumeInfo: *mut FSP_FSCTL_VOLUME_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Get file or directory attributes and security descriptor given a file name.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileName\n     The name of the file or directory to get the attributes and security descriptor for.\n @param PFileAttributes\n     Pointer to a memory location that will receive the file attributes on successful return\n     from this call. May be NULL.\n\n     If this call returns STATUS_REPARSE, the file system MAY place here the index of the\n     first reparse point within FileName. The file system MAY also leave this at its default\n     value of 0.\n @param SecurityDescriptor\n     Pointer to a buffer that will receive the file security descriptor on successful return\n     from this call. May be NULL.\n @param PSecurityDescriptorSize [in,out]\n     Pointer to the security descriptor buffer size. On input it contains the size of the\n     security descriptor buffer. On output it will contain the actual size of the security\n     descriptor copied into the security descriptor buffer. May be NULL.\n @return\n     STATUS_SUCCESS, STATUS_REPARSE or error code.\n\n     STATUS_REPARSE should be returned by file systems that support reparse points when\n     they encounter a FileName that contains reparse points anywhere but the final path\n     component."]
    pub GetSecurityByName: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileName: PWSTR,
            PFileAttributes: PUINT32,
            SecurityDescriptor: PSECURITY_DESCRIPTOR,
            PSecurityDescriptorSize: *mut SIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Create new file or directory.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileName\n     The name of the file or directory to be created.\n @param CreateOptions\n     Create options for this request. This parameter has the same meaning as the\n     CreateOptions parameter of the NtCreateFile API. User mode file systems should typically\n     only be concerned with the flag FILE_DIRECTORY_FILE, which is an instruction to create a\n     directory rather than a file. Some file systems may also want to pay attention to the\n     FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH flags, although these are\n     typically handled by the FSD component.\n @param GrantedAccess\n     Determines the specific access rights that have been granted for this request. Upon\n     receiving this call all access checks have been performed and the user mode file system\n     need not perform any additional checks. However this parameter may be useful to a user\n     mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n     which flags to use in its POSIX open() call.\n @param FileAttributes\n     File attributes to apply to the newly created file or directory.\n @param SecurityDescriptor\n     Security descriptor to apply to the newly created file or directory. This security\n     descriptor will always be in self-relative format. Its length can be retrieved using the\n     Windows GetSecurityDescriptorLength API. Will be NULL for named streams.\n @param AllocationSize\n     Allocation size for the newly created file.\n @param PFileContext [out]\n     Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub Create: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileName: PWSTR,
            CreateOptions: UINT32,
            GrantedAccess: UINT32,
            FileAttributes: UINT32,
            SecurityDescriptor: PSECURITY_DESCRIPTOR,
            AllocationSize: UINT64,
            PFileContext: *mut PVOID,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Open a file or directory.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileName\n     The name of the file or directory to be opened.\n @param CreateOptions\n     Create options for this request. This parameter has the same meaning as the\n     CreateOptions parameter of the NtCreateFile API. User mode file systems typically\n     do not need to do anything special with respect to this parameter. Some file systems may\n     also want to pay attention to the FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH\n     flags, although these are typically handled by the FSD component.\n @param GrantedAccess\n     Determines the specific access rights that have been granted for this request. Upon\n     receiving this call all access checks have been performed and the user mode file system\n     need not perform any additional checks. However this parameter may be useful to a user\n     mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n     which flags to use in its POSIX open() call.\n @param PFileContext [out]\n     Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub Open: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileName: PWSTR,
            CreateOptions: UINT32,
            GrantedAccess: UINT32,
            PFileContext: *mut PVOID,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Overwrite a file.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to overwrite.\n @param FileAttributes\n     File attributes to apply to the overwritten file.\n @param ReplaceFileAttributes\n     When TRUE the existing file attributes should be replaced with the new ones.\n     When FALSE the existing file attributes should be merged (or'ed) with the new ones.\n @param AllocationSize\n     Allocation size for the overwritten file.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub Overwrite: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileAttributes: UINT32,
            ReplaceFileAttributes: BOOLEAN,
            AllocationSize: UINT64,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Cleanup a file.\n\n When CreateFile is used to open or create a file the kernel creates a kernel mode file\n object (type FILE_OBJECT) and a handle for it, which it returns to user-mode. The handle may\n be duplicated (using DuplicateHandle), but all duplicate handles always refer to the same\n file object. When all handles for a particular file object get closed (using CloseHandle)\n the system sends a Cleanup request to the file system.\n\n There will be a Cleanup operation for every Create or Open operation posted to the user mode\n file system. However the Cleanup operation is <b>not</b> the final close operation on a file.\n The file system must be ready to receive additional operations until close time. This is true\n even when the file is being deleted!\n\n The Flags parameter contains information about the cleanup operation:\n <ul>\n <li>FspCleanupDelete -\n An important function of the Cleanup operation is to complete a delete operation. Deleting\n a file or directory in Windows is a three-stage process where the file is first opened, then\n tested to see if the delete can proceed and if the answer is positive the file is then\n deleted during Cleanup.\n\n If the file system supports POSIX unlink (FSP_FSCTL_VOLUME_PARAMS ::\n SupportsPosixUnlinkRename), then a Cleanup / FspCleanupDelete operation may arrive while\n there are other open file handles for this particular file node. If the file system does not\n support POSIX unlink, then a Cleanup / FspCleanupDelete operation will always be the last\n outstanding cleanup for this particular file node.\n </li>\n <li>FspCleanupSetAllocationSize -\n The NTFS and FAT file systems reset a file's allocation size when they receive the last\n outstanding cleanup for a particular file node. User mode file systems that implement\n allocation size and wish to duplicate the NTFS and FAT behavior can use this flag.\n </li>\n <li>\n FspCleanupSetArchiveBit -\n File systems that support the archive bit should set the file node's archive bit when this\n flag is set.\n </li>\n <li>FspCleanupSetLastAccessTime, FspCleanupSetLastWriteTime, FspCleanupSetChangeTime - File\n systems should set the corresponding file time when each one of these flags is set. Note that\n updating the last access time is expensive and a file system may choose to not implement it.\n </ul>\n\n There is no way to report failure of this operation. This is a Windows limitation.\n\n As an optimization a file system may specify the FSP_FSCTL_VOLUME_PARAMS ::\n PostCleanupWhenModifiedOnly flag. In this case the FSD will only post Cleanup requests when\n the file was modified/deleted.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to cleanup.\n @param FileName\n     The name of the file or directory to cleanup. Sent only when a Delete is requested.\n @param Flags\n     These flags determine whether the file was modified and whether to delete the file.\n @see\n     Close\n     CanDelete\n     SetDelete"]
    pub Cleanup: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            Flags: ULONG,
        ),
    >,
    #[doc = " Close a file.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to be closed."]
    pub Close: ::std::option::Option<
        unsafe extern "C" fn(FileSystem: *mut FSP_FILE_SYSTEM, FileContext: PVOID),
    >,
    #[doc = " Read a file.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to be read.\n @param Buffer\n     Pointer to a buffer that will receive the results of the read operation.\n @param Offset\n     Offset within the file to read from.\n @param Length\n     Length of data to read.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes read.\n @return\n     STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n     operation."]
    pub Read: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Buffer: PVOID,
            Offset: UINT64,
            Length: ULONG,
            PBytesTransferred: PULONG,
        ) -> NTSTATUS,
    >,
    #[doc = " Write a file.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to be written.\n @param Buffer\n     Pointer to a buffer that contains the data to write.\n @param Offset\n     Offset within the file to write to.\n @param Length\n     Length of data to write.\n @param WriteToEndOfFile\n     When TRUE the file system must write to the current end of file. In this case the Offset\n     parameter will contain the value -1.\n @param ConstrainedIo\n     When TRUE the file system must not extend the file (i.e. change the file size).\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes written.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n     operation."]
    pub Write: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Buffer: PVOID,
            Offset: UINT64,
            Length: ULONG,
            WriteToEndOfFile: BOOLEAN,
            ConstrainedIo: BOOLEAN,
            PBytesTransferred: PULONG,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Flush a file or volume.\n\n Note that the FSD will also flush all file/volume caches prior to invoking this operation.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to be flushed. When NULL the whole volume is being flushed.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc. Used when\n     flushing file (not volume).\n @return\n     STATUS_SUCCESS or error code."]
    pub Flush: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Get file or directory information.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to get information for.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub GetFileInfo: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Set file or directory basic information.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to set information for.\n @param FileAttributes\n     File attributes to apply to the file or directory. If the value INVALID_FILE_ATTRIBUTES\n     is sent, the file attributes should not be changed.\n @param CreationTime\n     Creation time to apply to the file or directory. If the value 0 is sent, the creation\n     time should not be changed.\n @param LastAccessTime\n     Last access time to apply to the file or directory. If the value 0 is sent, the last\n     access time should not be changed.\n @param LastWriteTime\n     Last write time to apply to the file or directory. If the value 0 is sent, the last\n     write time should not be changed.\n @param ChangeTime\n     Change time to apply to the file or directory. If the value 0 is sent, the change time\n     should not be changed.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub SetBasicInfo: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileAttributes: UINT32,
            CreationTime: UINT64,
            LastAccessTime: UINT64,
            LastWriteTime: UINT64,
            ChangeTime: UINT64,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Set file/allocation size.\n\n This function is used to change a file's sizes. Windows file systems maintain two kinds\n of sizes: the file size is where the End Of File (EOF) is, and the allocation size is the\n actual size that a file takes up on the \"disk\".\n\n The rules regarding file/allocation size are:\n <ul>\n <li>Allocation size must always be aligned to the allocation unit boundary. The allocation\n unit is the product <code>(UINT64)SectorSize * (UINT64)SectorsPerAllocationUnit</code> from\n the FSP_FSCTL_VOLUME_PARAMS structure. The FSD will always send properly aligned allocation\n sizes when setting the allocation size.</li>\n <li>Allocation size is always greater or equal to the file size.</li>\n <li>A file size of more than the current allocation size will also extend the allocation\n size to the next allocation unit boundary.</li>\n <li>An allocation size of less than the current file size should also truncate the current\n file size.</li>\n </ul>\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to set the file/allocation size for.\n @param NewSize\n     New file/allocation size to apply to the file.\n @param SetAllocationSize\n     If TRUE, then the allocation size is being set. if FALSE, then the file size is being set.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub SetFileSize: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            NewSize: UINT64,
            SetAllocationSize: BOOLEAN,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Determine whether a file or directory can be deleted.\n\n This function tests whether a file or directory can be safely deleted. This function does\n not need to perform access checks, but may performs tasks such as check for empty\n directories, etc.\n\n This function should <b>NEVER</b> delete the file or directory in question. Deletion should\n happen during Cleanup with the FspCleanupDelete flag set.\n\n This function gets called when Win32 API's such as DeleteFile or RemoveDirectory are used.\n It does not get called when a file or directory is opened with FILE_DELETE_ON_CLOSE.\n\n NOTE: If both CanDelete and SetDelete are defined, SetDelete takes precedence. However\n most file systems need only implement the CanDelete operation.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to test for deletion.\n @param FileName\n     The name of the file or directory to test for deletion.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     Cleanup\n     SetDelete"]
    pub CanDelete: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
        ) -> NTSTATUS,
    >,
    #[doc = " Renames a file or directory.\n\n The kernel mode FSD provides certain guarantees prior to posting a rename operation:\n <ul>\n <li>A file cannot be renamed if a file with the same name exists and has open handles.</li>\n <li>A directory cannot be renamed if it or any of its subdirectories contains a file that\n has open handles.</li>\n </ul>\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to be renamed.\n @param FileName\n     The current name of the file or directory to rename.\n @param NewFileName\n     The new name for the file or directory.\n @param ReplaceIfExists\n     Whether to replace a file that already exists at NewFileName.\n @return\n     STATUS_SUCCESS or error code."]
    pub Rename: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            NewFileName: PWSTR,
            ReplaceIfExists: BOOLEAN,
        ) -> NTSTATUS,
    >,
    #[doc = " Get file or directory security descriptor.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to get the security descriptor for.\n @param SecurityDescriptor\n     Pointer to a buffer that will receive the file security descriptor on successful return\n     from this call. May be NULL.\n @param PSecurityDescriptorSize [in,out]\n     Pointer to the security descriptor buffer size. On input it contains the size of the\n     security descriptor buffer. On output it will contain the actual size of the security\n     descriptor copied into the security descriptor buffer. Cannot be NULL.\n @return\n     STATUS_SUCCESS or error code."]
    pub GetSecurity: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            SecurityDescriptor: PSECURITY_DESCRIPTOR,
            PSecurityDescriptorSize: *mut SIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Set file or directory security descriptor.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to set the security descriptor for.\n @param SecurityInformation\n     Describes what parts of the file or directory security descriptor should\n     be modified.\n @param ModificationDescriptor\n     Describes the modifications to apply to the file or directory security descriptor.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     FspSetSecurityDescriptor\n     FspDeleteSecurityDescriptor"]
    pub SetSecurity: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            SecurityInformation: SECURITY_INFORMATION,
            ModificationDescriptor: PSECURITY_DESCRIPTOR,
        ) -> NTSTATUS,
    >,
    #[doc = " Read a directory.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the directory to be read.\n @param Pattern\n     The pattern to match against files in this directory. Can be NULL. The file system\n     can choose to ignore this parameter as the FSD will always perform its own pattern\n     matching on the returned results.\n @param Marker\n     A file name that marks where in the directory to start reading. Files with names\n     that are greater than (not equal to) this marker (in the directory order determined\n     by the file system) should be returned. Can be NULL.\n @param Buffer\n     Pointer to a buffer that will receive the results of the read operation.\n @param Length\n     Length of data to read.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes read.\n @return\n     STATUS_SUCCESS or error code. STATUS_PENDING is supported allowing for asynchronous\n     operation.\n @see\n     FspFileSystemAddDirInfo"]
    pub ReadDirectory: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Pattern: PWSTR,
            Marker: PWSTR,
            Buffer: PVOID,
            Length: ULONG,
            PBytesTransferred: PULONG,
        ) -> NTSTATUS,
    >,
    #[doc = " Resolve reparse points.\n\n Reparse points are a general mechanism for attaching special behavior to files.\n A file or directory can contain a reparse point. A reparse point is data that has\n special meaning to the file system, Windows or user applications. For example, NTFS\n and Windows use reparse points to implement symbolic links. As another example,\n a particular file system may use reparse points to emulate UNIX FIFO's.\n\n This function is expected to resolve as many reparse points as possible. If a reparse\n point is encountered that is not understood by the file system further reparse point\n resolution should stop; the reparse point data should be returned to the FSD with status\n STATUS_REPARSE/reparse-tag. If a reparse point (symbolic link) is encountered that is\n understood by the file system but points outside it, the reparse point should be\n resolved, but further reparse point resolution should stop; the resolved file name\n should be returned to the FSD with status STATUS_REPARSE/IO_REPARSE.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileName\n     The name of the file or directory to have its reparse points resolved.\n @param ReparsePointIndex\n     The index of the first reparse point within FileName.\n @param ResolveLastPathComponent\n     If FALSE, the last path component of FileName should not be resolved, even\n     if it is a reparse point that can be resolved. If TRUE, all path components\n     should be resolved if possible.\n @param PIoStatus\n     Pointer to storage that will receive the status to return to the FSD. When\n     this function succeeds it must set PIoStatus->Status to STATUS_REPARSE and\n     PIoStatus->Information to either IO_REPARSE or the reparse tag.\n @param Buffer\n     Pointer to a buffer that will receive the resolved file name (IO_REPARSE) or\n     reparse data (reparse tag). If the function returns a file name, it should\n     not be NULL terminated.\n @param PSize [in,out]\n     Pointer to the buffer size. On input it contains the size of the buffer.\n     On output it will contain the actual size of data copied.\n @return\n     STATUS_REPARSE or error code."]
    pub ResolveReparsePoints: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileName: PWSTR,
            ReparsePointIndex: UINT32,
            ResolveLastPathComponent: BOOLEAN,
            PIoStatus: PIO_STATUS_BLOCK,
            Buffer: PVOID,
            PSize: PSIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Get reparse point.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the reparse point.\n @param FileName\n     The file name of the reparse point.\n @param Buffer\n     Pointer to a buffer that will receive the results of this operation. If\n     the function returns a symbolic link path, it should not be NULL terminated.\n @param PSize [in,out]\n     Pointer to the buffer size. On input it contains the size of the buffer.\n     On output it will contain the actual size of data copied.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     SetReparsePoint"]
    pub GetReparsePoint: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            Buffer: PVOID,
            PSize: PSIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Set reparse point.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the reparse point.\n @param FileName\n     The file name of the reparse point.\n @param Buffer\n     Pointer to a buffer that contains the data for this operation. If this buffer\n     contains a symbolic link path, it should not be assumed to be NULL terminated.\n @param Size\n     Size of data to write.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     GetReparsePoint"]
    pub SetReparsePoint: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            Buffer: PVOID,
            Size: SIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Delete reparse point.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the reparse point.\n @param FileName\n     The file name of the reparse point.\n @param Buffer\n     Pointer to a buffer that contains the data for this operation.\n @param Size\n     Size of data to write.\n @return\n     STATUS_SUCCESS or error code."]
    pub DeleteReparsePoint: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            Buffer: PVOID,
            Size: SIZE_T,
        ) -> NTSTATUS,
    >,
    #[doc = " Get named streams information.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to get stream information for.\n @param Buffer\n     Pointer to a buffer that will receive the stream information.\n @param Length\n     Length of buffer.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes stored.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     FspFileSystemAddStreamInfo"]
    pub GetStreamInfo: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Buffer: PVOID,
            Length: ULONG,
            PBytesTransferred: PULONG,
        ) -> NTSTATUS,
    >,
    #[doc = " Get directory information for a single file or directory within a parent directory.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the parent directory.\n @param FileName\n     The name of the file or directory to get information for. This name is relative\n     to the parent directory and is a single path component.\n @param DirInfo [out]\n     Pointer to a structure that will receive the directory information on successful\n     return from this call. This information includes the file name, but also file\n     attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub GetDirInfoByName: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            DirInfo: *mut FSP_FSCTL_DIR_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Process control code.\n\n This function is called when a program uses the DeviceIoControl API.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to be controled.\n @param ControlCode\n     The control code for the operation. This code must have a DeviceType with bit\n     0x8000 set and must have a TransferType of METHOD_BUFFERED.\n @param InputBuffer\n     Pointer to a buffer that contains the input data.\n @param InputBufferLength\n     Input data length.\n @param OutputBuffer\n     Pointer to a buffer that will receive the output data.\n @param OutputBufferLength\n     Output data length.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes transferred.\n @return\n     STATUS_SUCCESS or error code."]
    pub Control: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            ControlCode: UINT32,
            InputBuffer: PVOID,
            InputBufferLength: ULONG,
            OutputBuffer: PVOID,
            OutputBufferLength: ULONG,
            PBytesTransferred: PULONG,
        ) -> NTSTATUS,
    >,
    #[doc = " Set the file delete flag.\n\n This function sets a flag to indicates whether the FSD file should delete a file\n when it is closed. This function does not need to perform access checks, but may\n performs tasks such as check for empty directories, etc.\n\n This function should <b>NEVER</b> delete the file or directory in question. Deletion should\n happen during Cleanup with the FspCleanupDelete flag set.\n\n This function gets called when Win32 API's such as DeleteFile or RemoveDirectory are used.\n It does not get called when a file or directory is opened with FILE_DELETE_ON_CLOSE.\n\n NOTE: If both CanDelete and SetDelete are defined, SetDelete takes precedence. However\n most file systems need only implement the CanDelete operation.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file or directory to set the delete flag for.\n @param FileName\n     The name of the file or directory to set the delete flag for.\n @param DeleteFile\n     If set to TRUE the FSD indicates that the file will be deleted on Cleanup; otherwise\n     it will not be deleted. It is legal to receive multiple SetDelete calls for the same\n     file with different DeleteFile parameters.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     Cleanup\n     CanDelete"]
    pub SetDelete: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileName: PWSTR,
            DeleteFileW: BOOLEAN,
        ) -> NTSTATUS,
    >,
    #[doc = " Create new file or directory.\n\n This function works like Create, except that it also accepts an extra buffer that\n may contain extended attributes or a reparse point.\n\n NOTE: If both Create and CreateEx are defined, CreateEx takes precedence.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileName\n     The name of the file or directory to be created.\n @param CreateOptions\n     Create options for this request. This parameter has the same meaning as the\n     CreateOptions parameter of the NtCreateFile API. User mode file systems should typically\n     only be concerned with the flag FILE_DIRECTORY_FILE, which is an instruction to create a\n     directory rather than a file. Some file systems may also want to pay attention to the\n     FILE_NO_INTERMEDIATE_BUFFERING and FILE_WRITE_THROUGH flags, although these are\n     typically handled by the FSD component.\n @param GrantedAccess\n     Determines the specific access rights that have been granted for this request. Upon\n     receiving this call all access checks have been performed and the user mode file system\n     need not perform any additional checks. However this parameter may be useful to a user\n     mode file system; for example the WinFsp-FUSE layer uses this parameter to determine\n     which flags to use in its POSIX open() call.\n @param FileAttributes\n     File attributes to apply to the newly created file or directory.\n @param SecurityDescriptor\n     Security descriptor to apply to the newly created file or directory. This security\n     descriptor will always be in self-relative format. Its length can be retrieved using the\n     Windows GetSecurityDescriptorLength API. Will be NULL for named streams.\n @param AllocationSize\n     Allocation size for the newly created file.\n @param ExtraBuffer\n     Extended attributes or reparse point buffer.\n @param ExtraLength\n     Extended attributes or reparse point buffer length.\n @param ExtraBufferIsReparsePoint\n     FALSE: extra buffer is extended attributes; TRUE: extra buffer is reparse point.\n @param PFileContext [out]\n     Pointer that will receive the file context on successful return from this call.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub CreateEx: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileName: PWSTR,
            CreateOptions: UINT32,
            GrantedAccess: UINT32,
            FileAttributes: UINT32,
            SecurityDescriptor: PSECURITY_DESCRIPTOR,
            AllocationSize: UINT64,
            ExtraBuffer: PVOID,
            ExtraLength: ULONG,
            ExtraBufferIsReparsePoint: BOOLEAN,
            PFileContext: *mut PVOID,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Overwrite a file.\n\n This function works like Overwrite, except that it also accepts EA (extended attributes).\n\n NOTE: If both Overwrite and OverwriteEx are defined, OverwriteEx takes precedence.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to overwrite.\n @param FileAttributes\n     File attributes to apply to the overwritten file.\n @param ReplaceFileAttributes\n     When TRUE the existing file attributes should be replaced with the new ones.\n     When FALSE the existing file attributes should be merged (or'ed) with the new ones.\n @param AllocationSize\n     Allocation size for the overwritten file.\n @param Ea\n     Extended attributes buffer.\n @param EaLength\n     Extended attributes buffer length.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code."]
    pub OverwriteEx: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            FileAttributes: UINT32,
            ReplaceFileAttributes: BOOLEAN,
            AllocationSize: UINT64,
            Ea: PFILE_FULL_EA_INFORMATION,
            EaLength: ULONG,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    #[doc = " Get extended attributes.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to get extended attributes for.\n @param Ea\n     Extended attributes buffer.\n @param EaLength\n     Extended attributes buffer length.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes transferred.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     SetEa\n     FspFileSystemAddEa"]
    pub GetEa: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Ea: PFILE_FULL_EA_INFORMATION,
            EaLength: ULONG,
            PBytesTransferred: PULONG,
        ) -> NTSTATUS,
    >,
    #[doc = " Set extended attributes.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param FileContext\n     The file context of the file to set extended attributes for.\n @param Ea\n     Extended attributes buffer.\n @param EaLength\n     Extended attributes buffer length.\n @param FileInfo [out]\n     Pointer to a structure that will receive the file information on successful return\n     from this call. This information includes file attributes, file times, etc.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     GetEa"]
    pub SetEa: ::std::option::Option<
        unsafe extern "C" fn(
            FileSystem: *mut FSP_FILE_SYSTEM,
            FileContext: PVOID,
            Ea: PFILE_FULL_EA_INFORMATION,
            EaLength: ULONG,
            FileInfo: *mut FSP_FSCTL_FILE_INFO,
        ) -> NTSTATUS,
    >,
    pub Obsolete0: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
    #[doc = " Inform the file system that its dispatcher has been stopped.\n\n Prior to WinFsp v2.0 the FSD would never unmount a file system volume unless\n the user mode file system requested the unmount. Since WinFsp v2.0 it is possible\n for the FSD to unmount a file system volume without an explicit user mode file system\n request. For example, this happens when the FSD is being uninstalled.\n\n A user mode file system can use this operation to determine when its dispatcher\n has been stopped. The Normally parameter can be used to determine why the dispatcher\n was stopped: it is TRUE when the file system is being stopped via\n FspFileSystemStopDispatcher and FALSE otherwise.\n\n When the file system receives a request with Normally == TRUE it need not take any\n extra steps. This case is the same as for pre-v2.0 versions: since the file system\n stopped the dispatcher via FspFileSystemStopDispatcher, it will likely exit its\n process soon.\n\n When the file system receives a request with Normally == FALSE it may need to take\n extra steps to exit its process as this is not done by default.\n\n A file system that uses the FspService infrastructure may use the\n FspFileSystemStopServiceIfNecessary API to correctly handle all cases.\n\n This operation is the last one that a file system will receive.\n\n @param FileSystem\n     The file system on which this request is posted.\n @param Normally\n     TRUE if the file system is being stopped via FspFileSystemStopDispatcher.\n     FALSE if the file system is being stopped because of another reason such\n     as driver unload/uninstall.\n @see\n     FspFileSystemStopServiceIfNecessary"]
    pub DispatcherStopped: ::std::option::Option<
        unsafe extern "C" fn(FileSystem: *mut FSP_FILE_SYSTEM, Normally: BOOLEAN),
    >,
    pub Reserved: [::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>; 31usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FSP_FILE_SYSTEM_INTERFACE"]
        [::std::mem::size_of::<_FSP_FILE_SYSTEM_INTERFACE>() - 512usize];
    ["Alignment of _FSP_FILE_SYSTEM_INTERFACE"]
        [::std::mem::align_of::<_FSP_FILE_SYSTEM_INTERFACE>() - 8usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetVolumeInfo"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetVolumeInfo) - 0usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetVolumeLabelW"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetVolumeLabelW) - 8usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetSecurityByName"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetSecurityByName) - 16usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Create"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Create) - 24usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Open"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Open) - 32usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Overwrite"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Overwrite) - 40usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Cleanup"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Cleanup) - 48usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Close"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Close) - 56usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Read"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Read) - 64usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Write"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Write) - 72usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Flush"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Flush) - 80usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetFileInfo"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetFileInfo) - 88usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetBasicInfo"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetBasicInfo) - 96usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetFileSize"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetFileSize) - 104usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::CanDelete"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, CanDelete) - 112usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Rename"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Rename) - 120usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetSecurity"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetSecurity) - 128usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetSecurity"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetSecurity) - 136usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::ReadDirectory"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, ReadDirectory) - 144usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::ResolveReparsePoints"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, ResolveReparsePoints) - 152usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetReparsePoint"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetReparsePoint) - 160usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetReparsePoint"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetReparsePoint) - 168usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::DeleteReparsePoint"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, DeleteReparsePoint) - 176usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetStreamInfo"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetStreamInfo) - 184usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetDirInfoByName"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetDirInfoByName) - 192usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Control"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Control) - 200usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetDelete"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetDelete) - 208usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::CreateEx"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, CreateEx) - 216usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::OverwriteEx"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, OverwriteEx) - 224usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::GetEa"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, GetEa) - 232usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::SetEa"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, SetEa) - 240usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Obsolete0"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Obsolete0) - 248usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::DispatcherStopped"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, DispatcherStopped) - 256usize];
    ["Offset of field: _FSP_FILE_SYSTEM_INTERFACE::Reserved"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_INTERFACE, Reserved) - 264usize];
};
#[doc = " @class FSP_FILE_SYSTEM\n File system interface.\n\n The operations in this interface must be implemented by the user mode\n file system. Not all operations need be implemented. For example,\n a user mode file system that does not wish to support reparse points,\n need not implement the reparse point operations.\n\n Most of the operations accept a FileContext parameter. This parameter\n has different meanings depending on the value of the FSP_FSCTL_VOLUME_PARAMS\n flags UmFileContextIsUserContext2 and UmFileContextIsFullContext.\n\n There are three cases to consider:\n <ul>\n <li>When both of these flags are unset (default), the FileContext parameter\n represents the file node. The file node is a void pointer (or an integer\n that can fit in a pointer) that is used to uniquely identify an open file.\n Opening the same file name should always yield the same file node value\n for as long as the file with that name remains open anywhere in the system.\n </li>\n <li>When the UmFileContextIsUserContext2 is set, the FileContext parameter\n represents the file descriptor. The file descriptor is a void pointer (or\n an integer that can fit in a pointer) that is used to identify an open\n instance of a file. Opening the same file name may yield a different file\n descriptor.\n </li>\n <li>When the UmFileContextIsFullContext is set, the FileContext parameter\n is a pointer to a FSP_FSCTL_TRANSACT_FULL_CONTEXT. This allows a user mode\n file system to access the low-level UserContext and UserContext2 values.\n The UserContext is used to store the file node and the UserContext2 is\n used to store the file descriptor for an open file.\n </li>\n </ul>"]
pub type FSP_FILE_SYSTEM_INTERFACE = _FSP_FILE_SYSTEM_INTERFACE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _FSP_FILE_SYSTEM {
    pub Version: UINT16,
    pub UserContext: PVOID,
    pub VolumeName: [WCHAR; 256usize],
    pub VolumeHandle: HANDLE,
    pub EnterOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
    pub LeaveOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
    pub Operations: [FSP_FILE_SYSTEM_OPERATION; 22usize],
    pub Interface: *const FSP_FILE_SYSTEM_INTERFACE,
    pub DispatcherThread: HANDLE,
    pub DispatcherThreadCount: ULONG,
    pub DispatcherResult: NTSTATUS,
    pub MountPoint: PWSTR,
    pub MountHandle: HANDLE,
    pub DebugLog: UINT32,
    pub OpGuardStrategy: FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY,
    pub OpGuardLock: SRWLOCK,
    pub UmFileContextIsUserContext2: BOOLEAN,
    pub UmFileContextIsFullContext: BOOLEAN,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub __bindgen_padding_0: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FSP_FILE_SYSTEM"][::std::mem::size_of::<_FSP_FILE_SYSTEM>() - 792usize];
    ["Alignment of _FSP_FILE_SYSTEM"][::std::mem::align_of::<_FSP_FILE_SYSTEM>() - 8usize];
    ["Offset of field: _FSP_FILE_SYSTEM::Version"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Version) - 0usize];
    ["Offset of field: _FSP_FILE_SYSTEM::UserContext"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UserContext) - 8usize];
    ["Offset of field: _FSP_FILE_SYSTEM::VolumeName"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, VolumeName) - 16usize];
    ["Offset of field: _FSP_FILE_SYSTEM::VolumeHandle"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, VolumeHandle) - 528usize];
    ["Offset of field: _FSP_FILE_SYSTEM::EnterOperation"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, EnterOperation) - 536usize];
    ["Offset of field: _FSP_FILE_SYSTEM::LeaveOperation"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, LeaveOperation) - 544usize];
    ["Offset of field: _FSP_FILE_SYSTEM::Operations"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Operations) - 552usize];
    ["Offset of field: _FSP_FILE_SYSTEM::Interface"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, Interface) - 728usize];
    ["Offset of field: _FSP_FILE_SYSTEM::DispatcherThread"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherThread) - 736usize];
    ["Offset of field: _FSP_FILE_SYSTEM::DispatcherThreadCount"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherThreadCount) - 744usize];
    ["Offset of field: _FSP_FILE_SYSTEM::DispatcherResult"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DispatcherResult) - 748usize];
    ["Offset of field: _FSP_FILE_SYSTEM::MountPoint"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, MountPoint) - 752usize];
    ["Offset of field: _FSP_FILE_SYSTEM::MountHandle"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, MountHandle) - 760usize];
    ["Offset of field: _FSP_FILE_SYSTEM::DebugLog"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, DebugLog) - 768usize];
    ["Offset of field: _FSP_FILE_SYSTEM::OpGuardStrategy"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, OpGuardStrategy) - 772usize];
    ["Offset of field: _FSP_FILE_SYSTEM::OpGuardLock"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, OpGuardLock) - 776usize];
    ["Offset of field: _FSP_FILE_SYSTEM::UmFileContextIsUserContext2"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UmFileContextIsUserContext2) - 784usize];
    ["Offset of field: _FSP_FILE_SYSTEM::UmFileContextIsFullContext"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM, UmFileContextIsFullContext) - 785usize];
};
impl Default for _FSP_FILE_SYSTEM {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl _FSP_FILE_SYSTEM {
    #[inline]
    pub fn UmNoReparsePointsDirCheck(&self) -> UINT16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_UmNoReparsePointsDirCheck(&mut self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmNoReparsePointsDirCheck_raw(this: *const Self) -> UINT16 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u16)
        }
    }
    #[inline]
    pub unsafe fn set_UmNoReparsePointsDirCheck_raw(this: *mut Self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn UmReservedFlags(&self) -> UINT16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 14u8) as u16) }
    }
    #[inline]
    pub fn set_UmReservedFlags(&mut self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 14u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn UmReservedFlags_raw(this: *const Self) -> UINT16 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                14u8,
            ) as u16)
        }
    }
    #[inline]
    pub unsafe fn set_UmReservedFlags_raw(this: *mut Self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                14u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DispatcherStopping(&self) -> UINT16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_DispatcherStopping(&mut self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DispatcherStopping_raw(this: *const Self) -> UINT16 {
        unsafe {
            ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::std::ptr::addr_of!((*this)._bitfield_1),
                15usize,
                1u8,
            ) as u16)
        }
    }
    #[inline]
    pub unsafe fn set_DispatcherStopping_raw(this: *mut Self, val: UINT16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                15usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        UmNoReparsePointsDirCheck: UINT16,
        UmReservedFlags: UINT16,
        DispatcherStopping: UINT16,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let UmNoReparsePointsDirCheck: u16 =
                unsafe { ::std::mem::transmute(UmNoReparsePointsDirCheck) };
            UmNoReparsePointsDirCheck as u64
        });
        __bindgen_bitfield_unit.set(1usize, 14u8, {
            let UmReservedFlags: u16 = unsafe { ::std::mem::transmute(UmReservedFlags) };
            UmReservedFlags as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let DispatcherStopping: u16 = unsafe { ::std::mem::transmute(DispatcherStopping) };
            DispatcherStopping as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _FSP_FILE_SYSTEM_OPERATION_CONTEXT {
    pub Request: *mut FSP_FSCTL_TRANSACT_REQ,
    pub Response: *mut FSP_FSCTL_TRANSACT_RSP,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FSP_FILE_SYSTEM_OPERATION_CONTEXT"]
        [::std::mem::size_of::<_FSP_FILE_SYSTEM_OPERATION_CONTEXT>() - 16usize];
    ["Alignment of _FSP_FILE_SYSTEM_OPERATION_CONTEXT"]
        [::std::mem::align_of::<_FSP_FILE_SYSTEM_OPERATION_CONTEXT>() - 8usize];
    ["Offset of field: _FSP_FILE_SYSTEM_OPERATION_CONTEXT::Request"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_OPERATION_CONTEXT, Request) - 0usize];
    ["Offset of field: _FSP_FILE_SYSTEM_OPERATION_CONTEXT::Response"]
        [::std::mem::offset_of!(_FSP_FILE_SYSTEM_OPERATION_CONTEXT, Response) - 8usize];
};
impl Default for _FSP_FILE_SYSTEM_OPERATION_CONTEXT {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type FSP_FILE_SYSTEM_OPERATION_CONTEXT = _FSP_FILE_SYSTEM_OPERATION_CONTEXT;
unsafe extern "C" {
    #[doc = " Check whether creating a file system object is possible.\n\n @param DevicePath\n     The name of the control device for this file system. This must be either\n     FSP_FSCTL_DISK_DEVICE_NAME or FSP_FSCTL_NET_DEVICE_NAME.\n @param MountPoint\n     The mount point for the new file system. A value of NULL means that the file system should\n     use the next available drive letter counting downwards from Z: as its mount point.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemPreflight(DevicePath: PWSTR, MountPoint: PWSTR) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Create a file system object.\n\n @param DevicePath\n     The name of the control device for this file system. This must be either\n     FSP_FSCTL_DISK_DEVICE_NAME or FSP_FSCTL_NET_DEVICE_NAME.\n @param VolumeParams\n     Volume parameters for the newly created file system.\n @param Interface\n     A pointer to the operations that implement this user mode file system.\n @param PFileSystem [out]\n     Pointer that will receive the file system object created on successful return from this\n     call.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemCreate(
        DevicePath: PWSTR,
        VolumeParams: *const FSP_FSCTL_VOLUME_PARAMS,
        Interface: *const FSP_FILE_SYSTEM_INTERFACE,
        PFileSystem: *mut *mut FSP_FILE_SYSTEM,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Delete a file system object.\n\n @param FileSystem\n     The file system object."]
    pub fn FspFileSystemDelete(FileSystem: *mut FSP_FILE_SYSTEM);
}
unsafe extern "C" {
    #[doc = " Set the mount point for a file system.\n\n This function supports drive letters (X:) or directories as mount points:\n <ul>\n <li>Drive letters: Refer to the documentation of the DefineDosDevice Windows API\n to better understand how they are created.</li>\n <li>Directories: They can be used as mount points for disk based file systems. They cannot\n be used for network file systems. This is a limitation that Windows imposes on junctions.</li>\n </ul>\n\n @param FileSystem\n     The file system object.\n @param MountPoint\n     The mount point for the new file system. A value of NULL means that the file system should\n     use the next available drive letter counting downwards from Z: as its mount point.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemSetMountPoint(
        FileSystem: *mut FSP_FILE_SYSTEM,
        MountPoint: PWSTR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemSetMountPointEx(
        FileSystem: *mut FSP_FILE_SYSTEM,
        MountPoint: PWSTR,
        SecurityDescriptor: PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Remove the mount point for a file system.\n\n @param FileSystem\n     The file system object."]
    pub fn FspFileSystemRemoveMountPoint(FileSystem: *mut FSP_FILE_SYSTEM);
}
unsafe extern "C" {
    #[doc = " Start the file system dispatcher.\n\n The file system dispatcher is used to dispatch operations posted by the FSD to the user mode\n file system. Once this call starts executing the user mode file system will start receiving\n file system requests from the kernel.\n\n @param FileSystem\n     The file system object.\n @param ThreadCount\n     The number of threads for the file system dispatcher. A value of 0 will create a default\n     number of threads and should be chosen in most cases.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemStartDispatcher(
        FileSystem: *mut FSP_FILE_SYSTEM,
        ThreadCount: ULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Stop the file system dispatcher.\n\n @param FileSystem\n     The file system object."]
    pub fn FspFileSystemStopDispatcher(FileSystem: *mut FSP_FILE_SYSTEM);
}
unsafe extern "C" {
    #[doc = " Send a response to the FSD.\n\n This call is not required when the user mode file system performs synchronous processing of\n requests. It is possible however for the following FSP_FILE_SYSTEM_INTERFACE operations to be\n processed asynchronously:\n <ul>\n <li>Read</li>\n <li>Write</li>\n <li>ReadDirectory</li>\n </ul>\n\n These operations are allowed to return STATUS_PENDING to postpone sending a response to the FSD.\n At a later time the file system can use FspFileSystemSendResponse to send the response.\n\n @param FileSystem\n     The file system object.\n @param Response\n     The response buffer."]
    pub fn FspFileSystemSendResponse(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    );
}
unsafe extern "C" {
    #[doc = " Begin notifying Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n This operation blocks concurrent file rename operations. File rename\n operations may interfere with file notification, because a file being\n notified may also be concurrently renamed. After all file change\n notifications have been issued, you must make sure to call\n FspFileSystemNotifyEnd to allow file rename operations to proceed.\n\n @param FileSystem\n     The file system object.\n @return\n     STATUS_SUCCESS or error code. The error code STATUS_CANT_WAIT means that\n     a file rename operation is currently in progress and the operation must be\n     retried at a later time."]
    pub fn FspFileSystemNotifyBegin(FileSystem: *mut FSP_FILE_SYSTEM, Timeout: ULONG) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " End notifying Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n This operation allows any blocked file rename operations to proceed.\n\n @param FileSystem\n     The file system object.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemNotifyEnd(FileSystem: *mut FSP_FILE_SYSTEM) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Notify Windows that the file system has file changes.\n\n A file system that wishes to notify Windows about file changes must\n first issue an FspFileSystemBegin call, followed by 0 or more\n FspFileSystemNotify calls, followed by an FspFileSystemNotifyEnd call.\n\n Note that FspFileSystemNotify requires file names to be normalized. A\n normalized file name is one that contains the correct case of all characters\n in the file name.\n\n For case-sensitive file systems all file names are normalized by definition.\n For case-insensitive file systems that implement file name normalization,\n a normalized file name is the one that the file system specifies in the\n response to Create or Open (see also FspFileSystemGetOpenFileInfo). For\n case-insensitive file systems that do not implement file name normalization\n a normalized file name is the upper case version of the file name used\n to open the file.\n\n @param FileSystem\n     The file system object.\n @param NotifyInfo\n     Buffer containing information about file changes.\n @param Size\n     Size of buffer.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspFileSystemNotify(
        FileSystem: *mut FSP_FILE_SYSTEM,
        NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
        Size: SIZE_T,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Get the current operation context.\n\n This function may be used only when servicing one of the FSP_FILE_SYSTEM_INTERFACE operations.\n The current operation context is stored in thread local storage. It allows access to the\n Request and Response associated with this operation.\n\n @return\n     The current operation context."]
    pub fn FspFileSystemGetOperationContext() -> *mut FSP_FILE_SYSTEM_OPERATION_CONTEXT;
}
unsafe extern "C" {
    pub fn FspFileSystemMountPointF(FileSystem: *mut FSP_FILE_SYSTEM) -> PWSTR;
}
unsafe extern "C" {
    pub fn FspFileSystemEnterOperationF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemLeaveOperationF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemSetOperationGuardF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        EnterOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
        LeaveOperation: FSP_FILE_SYSTEM_OPERATION_GUARD,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemSetOperationGuardStrategyF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        GuardStrategy: FSP_FILE_SYSTEM_OPERATION_GUARD_STRATEGY,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemSetOperationF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Index: ULONG,
        Operation: FSP_FILE_SYSTEM_OPERATION,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemGetDispatcherResultF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        PDispatcherResult: *mut NTSTATUS,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemSetDispatcherResultF(
        FileSystem: *mut FSP_FILE_SYSTEM,
        DispatcherResult: NTSTATUS,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemSetDebugLogF(FileSystem: *mut FSP_FILE_SYSTEM, DebugLog: UINT32);
}
unsafe extern "C" {
    pub fn FspFileSystemIsOperationCaseSensitiveF() -> BOOLEAN;
}
unsafe extern "C" {
    pub fn FspFileSystemOperationProcessIdF() -> UINT32;
}
unsafe extern "C" {
    pub fn FspFileSystemOpEnter(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpLeave(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpCreate(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpOverwrite(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpCleanup(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpClose(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpRead(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpWrite(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQueryInformation(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpSetInformation(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQueryEa(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpSetEa(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpFlushBuffers(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQueryVolumeInformation(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpSetVolumeInformation(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQueryDirectory(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpFileSystemControl(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpDeviceControl(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQuerySecurity(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpSetSecurity(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspFileSystemOpQueryStreamInformation(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        Response: *mut FSP_FSCTL_TRANSACT_RSP,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Add directory information to a buffer.\n\n This is a helper for implementing the ReadDirectory operation.\n\n @param DirInfo\n     The directory information to add. A value of NULL acts as an EOF marker for a ReadDirectory\n     operation.\n @param Buffer\n     Pointer to a buffer that will receive the results of the read operation. This should contain\n     the same value passed to the ReadDirectory Buffer parameter.\n @param Length\n     Length of data to read. This should contain the same value passed to the ReadDirectory\n     Length parameter.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes read. This should\n     contain the same value passed to the ReadDirectory PBytesTransferred parameter.\n     FspFileSystemAddDirInfo uses the value pointed by this parameter to track how much of the\n     buffer has been used so far.\n @return\n     TRUE if the directory information was added, FALSE if there was not enough space to add it.\n @see\n     ReadDirectory"]
    pub fn FspFileSystemAddDirInfo(
        DirInfo: *mut FSP_FSCTL_DIR_INFO,
        Buffer: PVOID,
        Length: ULONG,
        PBytesTransferred: PULONG,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Find reparse point in file name.\n\n Given a file name this function returns an index to the first path component that is a reparse\n point. The function will call the supplied GetReparsePointByName function for every path\n component until it finds a reparse point or the whole path is processed.\n\n This is a helper for implementing the GetSecurityByName operation in file systems\n that support reparse points.\n\n @param FileSystem\n     The file system object.\n @param GetReparsePointByName\n     Pointer to function that can retrieve reparse point information by name. The\n     FspFileSystemFindReparsePoint will call this function with the Buffer and PSize\n     arguments set to NULL. The function should return STATUS_SUCCESS if the passed\n     FileName is a reparse point or STATUS_NOT_A_REPARSE_POINT (or other error code)\n     otherwise.\n @param Context\n     User context to supply to GetReparsePointByName.\n @param FileName\n     The name of the file or directory.\n @param PReparsePointIndex\n     Pointer to a memory location that will receive the index of the first reparse point\n     within FileName. A value is only placed in this memory location if the function returns\n     TRUE. May be NULL.\n @return\n     TRUE if a reparse point was found, FALSE otherwise.\n @see\n     GetSecurityByName"]
    pub fn FspFileSystemFindReparsePoint(
        FileSystem: *mut FSP_FILE_SYSTEM,
        GetReparsePointByName: ::std::option::Option<
            unsafe extern "C" fn(
                FileSystem: *mut FSP_FILE_SYSTEM,
                Context: PVOID,
                FileName: PWSTR,
                IsDirectory: BOOLEAN,
                Buffer: PVOID,
                PSize: PSIZE_T,
            ) -> NTSTATUS,
        >,
        Context: PVOID,
        FileName: PWSTR,
        PReparsePointIndex: PUINT32,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Resolve reparse points.\n\n Given a file name (and an index where to start resolving) this function will attempt to\n resolve as many reparse points as possible. The function will call the supplied\n GetReparsePointByName function for every path component until it resolves the reparse points\n or the whole path is processed.\n\n This is a helper for implementing the ResolveReparsePoints operation in file systems\n that support reparse points.\n\n @param FileSystem\n     The file system object.\n @param GetReparsePointByName\n     Pointer to function that can retrieve reparse point information by name. The function\n     should return STATUS_SUCCESS if the passed FileName is a reparse point or\n     STATUS_NOT_A_REPARSE_POINT (or other error code) otherwise.\n @param Context\n     User context to supply to GetReparsePointByName.\n @param FileName\n     The name of the file or directory to have its reparse points resolved.\n @param ReparsePointIndex\n     The index of the first reparse point within FileName.\n @param ResolveLastPathComponent\n     If FALSE, the last path component of FileName should not be resolved, even\n     if it is a reparse point that can be resolved. If TRUE, all path components\n     should be resolved if possible.\n @param PIoStatus\n     Pointer to storage that will receive the status to return to the FSD. When\n     this function succeeds it must set PIoStatus->Status to STATUS_REPARSE and\n     PIoStatus->Information to either IO_REPARSE or the reparse tag.\n @param Buffer\n     Pointer to a buffer that will receive the resolved file name (IO_REPARSE) or\n     reparse data (reparse tag). If the function returns a file name, it should\n     not be NULL terminated.\n @param PSize [in,out]\n     Pointer to the buffer size. On input it contains the size of the buffer.\n     On output it will contain the actual size of data copied.\n @return\n     STATUS_REPARSE or error code.\n @see\n     ResolveReparsePoints"]
    pub fn FspFileSystemResolveReparsePoints(
        FileSystem: *mut FSP_FILE_SYSTEM,
        GetReparsePointByName: ::std::option::Option<
            unsafe extern "C" fn(
                FileSystem: *mut FSP_FILE_SYSTEM,
                Context: PVOID,
                FileName: PWSTR,
                IsDirectory: BOOLEAN,
                Buffer: PVOID,
                PSize: PSIZE_T,
            ) -> NTSTATUS,
        >,
        Context: PVOID,
        FileName: PWSTR,
        ReparsePointIndex: UINT32,
        ResolveLastPathComponent: BOOLEAN,
        PIoStatus: PIO_STATUS_BLOCK,
        Buffer: PVOID,
        PSize: PSIZE_T,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Test whether reparse data can be replaced.\n\n This is a helper for implementing the SetReparsePoint/DeleteReparsePoint operation\n in file systems that support reparse points.\n\n @param CurrentReparseData\n     Pointer to the current reparse data.\n @param CurrentReparseDataSize\n     Pointer to the current reparse data size.\n @param ReplaceReparseData\n     Pointer to the replacement reparse data.\n @param ReplaceReparseDataSize\n     Pointer to the replacement reparse data size.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     SetReparsePoint\n     DeleteReparsePoint"]
    pub fn FspFileSystemCanReplaceReparsePoint(
        CurrentReparseData: PVOID,
        CurrentReparseDataSize: SIZE_T,
        ReplaceReparseData: PVOID,
        ReplaceReparseDataSize: SIZE_T,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Add named stream information to a buffer.\n\n This is a helper for implementing the GetStreamInfo operation.\n\n @param StreamInfo\n     The stream information to add. A value of NULL acts as an EOF marker for a GetStreamInfo\n     operation.\n @param Buffer\n     Pointer to a buffer that will receive the stream information. This should contain\n     the same value passed to the GetStreamInfo Buffer parameter.\n @param Length\n     Length of buffer. This should contain the same value passed to the GetStreamInfo\n     Length parameter.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes stored. This should\n     contain the same value passed to the GetStreamInfo PBytesTransferred parameter.\n @return\n     TRUE if the stream information was added, FALSE if there was not enough space to add it.\n @see\n     GetStreamInfo"]
    pub fn FspFileSystemAddStreamInfo(
        StreamInfo: *mut FSP_FSCTL_STREAM_INFO,
        Buffer: PVOID,
        Length: ULONG,
        PBytesTransferred: PULONG,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Enumerate extended attributes in a buffer.\n\n This is a helper for implementing the CreateEx and SetEa operations in file systems\n that support extended attributes.\n\n @param FileSystem\n     The file system object.\n @param EnumerateEa\n     Pointer to function that receives a single extended attribute. The function\n     should return STATUS_SUCCESS or an error code if unsuccessful.\n @param Context\n     User context to supply to EnumEa.\n @param Ea\n     Extended attributes buffer.\n @param EaLength\n     Extended attributes buffer length.\n @return\n     STATUS_SUCCESS or error code from EnumerateEa."]
    pub fn FspFileSystemEnumerateEa(
        FileSystem: *mut FSP_FILE_SYSTEM,
        EnumerateEa: ::std::option::Option<
            unsafe extern "C" fn(
                FileSystem: *mut FSP_FILE_SYSTEM,
                Context: PVOID,
                SingleEa: PFILE_FULL_EA_INFORMATION,
            ) -> NTSTATUS,
        >,
        Context: PVOID,
        Ea: PFILE_FULL_EA_INFORMATION,
        EaLength: ULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Add extended attribute to a buffer.\n\n This is a helper for implementing the GetEa operation.\n\n @param SingleEa\n     The extended attribute to add. A value of NULL acts as an EOF marker for a GetEa\n     operation.\n @param Ea\n     Pointer to a buffer that will receive the extended attribute. This should contain\n     the same value passed to the GetEa Ea parameter.\n @param EaLength\n     Length of buffer. This should contain the same value passed to the GetEa\n     EaLength parameter.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes stored. This should\n     contain the same value passed to the GetEa PBytesTransferred parameter.\n @return\n     TRUE if the extended attribute was added, FALSE if there was not enough space to add it.\n @see\n     GetEa"]
    pub fn FspFileSystemAddEa(
        SingleEa: PFILE_FULL_EA_INFORMATION,
        Ea: PFILE_FULL_EA_INFORMATION,
        EaLength: ULONG,
        PBytesTransferred: PULONG,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Add notify information to a buffer.\n\n This is a helper for filling a buffer to use with FspFileSystemNotify.\n\n @param NotifyInfo\n     The notify information to add.\n @param Buffer\n     Pointer to a buffer that will receive the notify information.\n @param Length\n     Length of buffer.\n @param PBytesTransferred [out]\n     Pointer to a memory location that will receive the actual number of bytes stored. This should\n     be initialized to 0 prior to the first call to FspFileSystemAddNotifyInfo for a particular\n     buffer.\n @return\n     TRUE if the notify information was added, FALSE if there was not enough space to add it.\n @see\n     FspFileSystemNotify"]
    pub fn FspFileSystemAddNotifyInfo(
        NotifyInfo: *mut FSP_FSCTL_NOTIFY_INFO,
        Buffer: PVOID,
        Length: ULONG,
        PBytesTransferred: PULONG,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Stop a file system service, if any.\n\n This is a helper for implementing the DispatcherStopped operation, but only for file systems\n that use the FspService infrastructure.\n\n @param FileSystem\n     The file system object.\n @param Normally\n     TRUE if the file system is being stopped via FspFileSystemStopDispatcher.\n     FALSE if the file system is being stopped because of another reason such\n     as driver unload/uninstall.\n @see\n     DispatcherStopped"]
    pub fn FspFileSystemStopServiceIfNecessary(FileSystem: *mut FSP_FILE_SYSTEM, Normally: BOOLEAN);
}
unsafe extern "C" {
    pub fn FspFileSystemAcquireDirectoryBufferEx(
        PDirBuffer: *mut PVOID,
        Reset: BOOLEAN,
        CapacityHint: ULONG,
        PResult: PNTSTATUS,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    pub fn FspFileSystemAcquireDirectoryBuffer(
        PDirBuffer: *mut PVOID,
        Reset: BOOLEAN,
        PResult: PNTSTATUS,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    pub fn FspFileSystemFillDirectoryBuffer(
        PDirBuffer: *mut PVOID,
        DirInfo: *mut FSP_FSCTL_DIR_INFO,
        PResult: PNTSTATUS,
    ) -> BOOLEAN;
}
unsafe extern "C" {
    pub fn FspFileSystemReleaseDirectoryBuffer(PDirBuffer: *mut PVOID);
}
unsafe extern "C" {
    pub fn FspFileSystemReadDirectoryBuffer(
        PDirBuffer: *mut PVOID,
        Marker: PWSTR,
        Buffer: PVOID,
        Length: ULONG,
        PBytesTransferred: PULONG,
    );
}
unsafe extern "C" {
    pub fn FspFileSystemDeleteDirectoryBuffer(PDirBuffer: *mut PVOID);
}
unsafe extern "C" {
    pub fn FspGetFileGenericMapping() -> PGENERIC_MAPPING;
}
unsafe extern "C" {
    pub fn FspAccessCheckEx(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        CheckParentOrMain: BOOLEAN,
        AllowTraverseCheck: BOOLEAN,
        DesiredAccess: UINT32,
        PGrantedAccess: PUINT32,
        PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspCreateSecurityDescriptor(
        FileSystem: *mut FSP_FILE_SYSTEM,
        Request: *mut FSP_FSCTL_TRANSACT_REQ,
        ParentDescriptor: PSECURITY_DESCRIPTOR,
        PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Modify security descriptor.\n\n This is a helper for implementing the SetSecurity operation.\n\n @param InputDescriptor\n     The input security descriptor to be modified.\n @param SecurityInformation\n     Describes what parts of the InputDescriptor should be modified. This should contain\n     the same value passed to the SetSecurity SecurityInformation parameter.\n @param ModificationDescriptor\n     Describes the modifications to apply to the InputDescriptor. This should contain\n     the same value passed to the SetSecurity ModificationDescriptor parameter.\n @param PSecurityDescriptor [out]\n     Pointer to a memory location that will receive the resulting security descriptor.\n     This security descriptor can be later freed using FspDeleteSecurityDescriptor.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     SetSecurity\n     FspDeleteSecurityDescriptor"]
    pub fn FspSetSecurityDescriptor(
        InputDescriptor: PSECURITY_DESCRIPTOR,
        SecurityInformation: SECURITY_INFORMATION,
        ModificationDescriptor: PSECURITY_DESCRIPTOR,
        PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Delete security descriptor.\n\n This is a helper for implementing the SetSecurity operation.\n\n @param SecurityDescriptor\n     The security descriptor to be deleted.\n @param CreateFunc\n     Function used to create the security descriptor. This parameter should be\n     set to FspSetSecurityDescriptor for the public API.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     SetSecurity\n     FspSetSecurityDescriptor"]
    pub fn FspDeleteSecurityDescriptor(
        SecurityDescriptor: PSECURITY_DESCRIPTOR,
        CreateFunc: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
    );
}
unsafe extern "C" {
    pub fn FspPosixSetUidMap(Uid: *mut UINT32, Sid: *mut PSID, Count: ULONG) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMapUidToSid(Uid: UINT32, PSid: *mut PSID) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMapSidToUid(Sid: PSID, PUid: PUINT32) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspDeleteSid(
        Sid: PSID,
        CreateFunc: ::std::option::Option<unsafe extern "C" fn() -> NTSTATUS>,
    );
}
unsafe extern "C" {
    pub fn FspPosixMapPermissionsToSecurityDescriptor(
        Uid: UINT32,
        Gid: UINT32,
        Mode: UINT32,
        PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMergePermissionsToSecurityDescriptor(
        Uid: UINT32,
        Gid: UINT32,
        Mode: UINT32,
        ExistingSecurityDescriptor: PSECURITY_DESCRIPTOR,
        PSecurityDescriptor: *mut PSECURITY_DESCRIPTOR,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMapSecurityDescriptorToPermissions(
        SecurityDescriptor: PSECURITY_DESCRIPTOR,
        PUid: PUINT32,
        PGid: PUINT32,
        PMode: PUINT32,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMapWindowsToPosixPathEx(
        WindowsPath: PWSTR,
        PPosixPath: *mut *mut ::std::os::raw::c_char,
        Translate: BOOLEAN,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixMapPosixToWindowsPathEx(
        PosixPath: *const ::std::os::raw::c_char,
        PWindowsPath: *mut PWSTR,
        Translate: BOOLEAN,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspPosixDeletePath(Path: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
    pub fn FspPosixEncodeWindowsPath(WindowsPath: PWSTR, Size: ULONG);
}
unsafe extern "C" {
    pub fn FspPosixDecodeWindowsPath(WindowsPath: PWSTR, Size: ULONG);
}
unsafe extern "C" {
    pub fn FspPathPrefix(Path: PWSTR, PPrefix: *mut PWSTR, PRemain: *mut PWSTR, Root: PWSTR);
}
unsafe extern "C" {
    pub fn FspPathSuffix(Path: PWSTR, PRemain: *mut PWSTR, PSuffix: *mut PWSTR, Root: PWSTR);
}
unsafe extern "C" {
    pub fn FspPathCombine(Prefix: PWSTR, Suffix: PWSTR);
}
#[doc = " @group Service Framework\n\n User mode file systems typically are run as Windows services. WinFsp provides an API to make\n the creation of Windows services easier. This API is provided for convenience and is not\n necessary to expose a user mode file system to Windows."]
pub type FSP_SERVICE = _FSP_SERVICE;
pub type FSP_SERVICE_START = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut FSP_SERVICE, arg2: ULONG, arg3: *mut PWSTR) -> NTSTATUS,
>;
pub type FSP_SERVICE_STOP =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut FSP_SERVICE) -> NTSTATUS>;
pub type FSP_SERVICE_CONTROL = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut FSP_SERVICE, arg2: ULONG, arg3: ULONG, arg4: PVOID) -> NTSTATUS,
>;
#[repr(C)]
#[derive(Debug)]
pub struct _FSP_SERVICE {
    pub Version: UINT16,
    pub UserContext: PVOID,
    pub OnStart: FSP_SERVICE_START,
    pub OnStop: FSP_SERVICE_STOP,
    pub OnControl: FSP_SERVICE_CONTROL,
    pub AcceptControl: ULONG,
    pub ExitCode: ULONG,
    pub StatusHandle: SERVICE_STATUS_HANDLE,
    pub ServiceStatus: SERVICE_STATUS,
    pub ServiceStatusGuard: CRITICAL_SECTION,
    pub ServiceStopGuard: CRITICAL_SECTION,
    pub AllowConsoleMode: BOOLEAN,
    pub ServiceName: __IncompleteArrayField<WCHAR>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FSP_SERVICE"][::std::mem::size_of::<_FSP_SERVICE>() - 176usize];
    ["Alignment of _FSP_SERVICE"][::std::mem::align_of::<_FSP_SERVICE>() - 8usize];
    ["Offset of field: _FSP_SERVICE::Version"]
        [::std::mem::offset_of!(_FSP_SERVICE, Version) - 0usize];
    ["Offset of field: _FSP_SERVICE::UserContext"]
        [::std::mem::offset_of!(_FSP_SERVICE, UserContext) - 8usize];
    ["Offset of field: _FSP_SERVICE::OnStart"]
        [::std::mem::offset_of!(_FSP_SERVICE, OnStart) - 16usize];
    ["Offset of field: _FSP_SERVICE::OnStop"]
        [::std::mem::offset_of!(_FSP_SERVICE, OnStop) - 24usize];
    ["Offset of field: _FSP_SERVICE::OnControl"]
        [::std::mem::offset_of!(_FSP_SERVICE, OnControl) - 32usize];
    ["Offset of field: _FSP_SERVICE::AcceptControl"]
        [::std::mem::offset_of!(_FSP_SERVICE, AcceptControl) - 40usize];
    ["Offset of field: _FSP_SERVICE::ExitCode"]
        [::std::mem::offset_of!(_FSP_SERVICE, ExitCode) - 44usize];
    ["Offset of field: _FSP_SERVICE::StatusHandle"]
        [::std::mem::offset_of!(_FSP_SERVICE, StatusHandle) - 48usize];
    ["Offset of field: _FSP_SERVICE::ServiceStatus"]
        [::std::mem::offset_of!(_FSP_SERVICE, ServiceStatus) - 56usize];
    ["Offset of field: _FSP_SERVICE::ServiceStatusGuard"]
        [::std::mem::offset_of!(_FSP_SERVICE, ServiceStatusGuard) - 88usize];
    ["Offset of field: _FSP_SERVICE::ServiceStopGuard"]
        [::std::mem::offset_of!(_FSP_SERVICE, ServiceStopGuard) - 128usize];
    ["Offset of field: _FSP_SERVICE::AllowConsoleMode"]
        [::std::mem::offset_of!(_FSP_SERVICE, AllowConsoleMode) - 168usize];
    ["Offset of field: _FSP_SERVICE::ServiceName"]
        [::std::mem::offset_of!(_FSP_SERVICE, ServiceName) - 170usize];
};
impl Default for _FSP_SERVICE {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[doc = " Run a service.\n\n This function wraps calls to FspServiceCreate, FspServiceLoop and FspServiceDelete to create,\n run and delete a service. It is intended to be used from a service's main/wmain function.\n\n This function runs a service with console mode allowed.\n\n @param ServiceName\n     The name of the service.\n @param OnStart\n     Function to call when the service starts.\n @param OnStop\n     Function to call when the service stops.\n @param OnControl\n     Function to call when the service receives a service control code.\n @return\n     Service process exit code."]
    pub fn FspServiceRunEx(
        ServiceName: PWSTR,
        OnStart: FSP_SERVICE_START,
        OnStop: FSP_SERVICE_STOP,
        OnControl: FSP_SERVICE_CONTROL,
        UserContext: PVOID,
    ) -> ULONG;
}
unsafe extern "C" {
    #[doc = " Create a service object.\n\n @param ServiceName\n     The name of the service.\n @param OnStart\n     Function to call when the service starts.\n @param OnStop\n     Function to call when the service stops.\n @param OnControl\n     Function to call when the service receives a service control code.\n @param PService [out]\n     Pointer that will receive the service object created on successful return from this\n     call.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspServiceCreate(
        ServiceName: PWSTR,
        OnStart: FSP_SERVICE_START,
        OnStop: FSP_SERVICE_STOP,
        OnControl: FSP_SERVICE_CONTROL,
        PService: *mut *mut FSP_SERVICE,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Delete a service object.\n\n @param Service\n     The service object."]
    pub fn FspServiceDelete(Service: *mut FSP_SERVICE);
}
unsafe extern "C" {
    #[doc = " Allow a service to run in console mode.\n\n A service that is run in console mode runs with a console attached and outside the control of\n the Service Control Manager. This is useful for debugging and testing a service during\n development.\n\n User mode file systems that wish to use the WinFsp Launcher functionality must also use this\n call. The WinFsp Launcher is a Windows service that can be configured to launch and manage\n multiple instances of a user mode file system.\n\n @param Service\n     The service object."]
    pub fn FspServiceAllowConsoleMode(Service: *mut FSP_SERVICE);
}
unsafe extern "C" {
    #[doc = " Configure the control codes that a service accepts.\n\n This API should be used prior to Start operations.\n\n @param Service\n     The service object.\n @param Control\n     The control codes to accept. Note that the SERVICE_ACCEPT_PAUSE_CONTINUE code is silently\n     ignored."]
    pub fn FspServiceAcceptControl(Service: *mut FSP_SERVICE, Control: ULONG);
}
unsafe extern "C" {
    #[doc = " Request additional time from the Service Control Manager.\n\n This API should be used during Start and Stop operations only.\n\n @param Service\n     The service object.\n @param Time\n     Additional time (in milliseconds)."]
    pub fn FspServiceRequestTime(Service: *mut FSP_SERVICE, Time: ULONG);
}
unsafe extern "C" {
    #[doc = " Set the service process exit code.\n\n @param Service\n     The service object.\n @param ExitCode\n     Service process exit code."]
    pub fn FspServiceSetExitCode(Service: *mut FSP_SERVICE, ExitCode: ULONG);
}
unsafe extern "C" {
    #[doc = " Get the service process exit code.\n\n @param Service\n     The service object.\n @return\n     Service process exit code."]
    pub fn FspServiceGetExitCode(Service: *mut FSP_SERVICE) -> ULONG;
}
unsafe extern "C" {
    #[doc = " Run a service main loop.\n\n This function starts and runs a service. It executes the Windows StartServiceCtrlDispatcher API\n to connect the service process to the Service Control Manager. If the Service Control Manager is\n not available (and console mode is allowed) it will enter console mode.\n\n This function should be called once per process.\n\n @param Service\n     The service object.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspServiceLoop(Service: *mut FSP_SERVICE) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Stops a running service.\n\n Stopping a service usually happens when the Service Control Manager instructs the service to\n stop. In some situations (e.g. fatal errors) the service may wish to stop itself. It can do so\n in a clean manner by calling this function.\n\n @param Service\n     The service object.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspServiceStop(Service: *mut FSP_SERVICE);
}
unsafe extern "C" {
    #[doc = " Determine if the current process is running in user interactive mode.\n\n @return\n     TRUE if the process is running in running user interactive mode."]
    pub fn FspServiceIsInteractive() -> BOOLEAN;
}
unsafe extern "C" {
    #[doc = " Check if the supplied token is from the service context.\n\n @param Token\n     Token to check. Pass NULL to check the current process token.\n @param PIsLocalSystem\n     Pointer to a boolean that will receive a TRUE value if the token belongs to LocalSystem\n     and FALSE otherwise. May be NULL.\n @return\n     STATUS_SUCCESS if the token is from the service context. STATUS_ACCESS_DENIED if it is not.\n     Other error codes are possible."]
    pub fn FspServiceContextCheck(Token: HANDLE, PIsLocalSystem: PBOOLEAN) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Log a service message.\n\n This function can be used to log an arbitrary message to the Windows Event Log or to the current\n console if running in user interactive mode.\n\n @param Type\n     One of EVENTLOG_INFORMATION_TYPE, EVENTLOG_WARNING_TYPE, EVENTLOG_ERROR_TYPE.\n @param Format\n     Format specification. This function uses the Windows wsprintf API for formatting. Refer to\n     that API's documentation for details on the format specification."]
    pub fn FspServiceLog(Type: ULONG, Format: PWSTR, ...);
}
unsafe extern "C" {
    pub fn FspServiceLogV(Type: ULONG, Format: PWSTR, ap: va_list);
}
unsafe extern "C" {
    pub fn FspNtStatusFromWin32(Error: DWORD) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspWin32FromNtStatus(Status: NTSTATUS) -> DWORD;
}
unsafe extern "C" {
    pub fn FspEventLog(Type: ULONG, Format: PWSTR, ...);
}
unsafe extern "C" {
    pub fn FspEventLogV(Type: ULONG, Format: PWSTR, ap: va_list);
}
unsafe extern "C" {
    pub fn FspDebugLogSetHandle(Handle: HANDLE);
}
unsafe extern "C" {
    pub fn FspDebugLog(Format: *const ::std::os::raw::c_char, ...);
}
unsafe extern "C" {
    pub fn FspDebugLogSD(
        Format: *const ::std::os::raw::c_char,
        SecurityDescriptor: PSECURITY_DESCRIPTOR,
    );
}
unsafe extern "C" {
    pub fn FspDebugLogSid(format: *const ::std::os::raw::c_char, Sid: PSID);
}
unsafe extern "C" {
    pub fn FspDebugLogFT(Format: *const ::std::os::raw::c_char, FileTime: PFILETIME);
}
unsafe extern "C" {
    pub fn FspDebugLogRequest(Request: *mut FSP_FSCTL_TRANSACT_REQ);
}
unsafe extern "C" {
    pub fn FspDebugLogResponse(Response: *mut FSP_FSCTL_TRANSACT_RSP);
}
unsafe extern "C" {
    pub fn FspCallNamedPipeSecurely(
        PipeName: PWSTR,
        InBuffer: PVOID,
        InBufferSize: ULONG,
        OutBuffer: PVOID,
        OutBufferSize: ULONG,
        PBytesTransferred: PULONG,
        Timeout: ULONG,
        Sid: PSID,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspCallNamedPipeSecurelyEx(
        PipeName: PWSTR,
        InBuffer: PVOID,
        InBufferSize: ULONG,
        OutBuffer: PVOID,
        OutBufferSize: ULONG,
        PBytesTransferred: PULONG,
        Timeout: ULONG,
        AllowImpersonation: BOOLEAN,
        Sid: PSID,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspVersion(PVersion: PUINT32) -> NTSTATUS;
}
unsafe extern "C" {
    pub fn FspSxsIdent() -> PWSTR;
}
pub const FspLaunchCmdStart: _bindgen_ty_7 = 83;
pub const FspLaunchCmdStartWithSecret: _bindgen_ty_7 = 88;
pub const FspLaunchCmdStop: _bindgen_ty_7 = 84;
pub const FspLaunchCmdGetInfo: _bindgen_ty_7 = 73;
pub const FspLaunchCmdGetNameList: _bindgen_ty_7 = 76;
pub const FspLaunchCmdDefineDosDevice: _bindgen_ty_7 = 68;
pub const FspLaunchCmdQuit: _bindgen_ty_7 = 81;
pub type _bindgen_ty_7 = ::std::os::raw::c_int;
pub const FspLaunchCmdSuccess: _bindgen_ty_8 = 36;
pub const FspLaunchCmdFailure: _bindgen_ty_8 = 33;
pub type _bindgen_ty_8 = ::std::os::raw::c_int;
unsafe extern "C" {
    #[doc = " @group Launch Control\n/\n/**\n Call launcher pipe.\n\n This function is used to send a command to the launcher and receive a response.\n\n @param Command\n     Launcher command to send. For example, the 'L' launcher command instructs\n     the launcher to list all running service instances.\n @param Argc\n     Command argument count. May be 0.\n @param Argv\n     Command argument array. May be NULL.\n @param Argl\n     Command argument length array. May be NULL. If this is NULL all command arguments\n     are assumed to be NULL-terminated strings. It is also possible for specific arguments\n     to be NULL-terminated; in this case pass -1 in the corresponding Argl position.\n @param Buffer\n     Buffer that receives the command response. May be NULL.\n @param PSize\n     Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n     contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchCallLauncherPipe(
        Command: WCHAR,
        Argc: ULONG,
        Argv: *mut PWSTR,
        Argl: *mut ULONG,
        Buffer: PWSTR,
        PSize: PULONG,
        PLauncherError: PULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Call launcher pipe.\n\n This function is used to send a command to the launcher and receive a response.\n\n @param Command\n     Launcher command to send. For example, the 'L' launcher command instructs\n     the launcher to list all running service instances.\n @param Argc\n     Command argument count. May be 0.\n @param Argv\n     Command argument array. May be NULL.\n @param Argl\n     Command argument length array. May be NULL. If this is NULL all command arguments\n     are assumed to be NULL-terminated strings. It is also possible for specific arguments\n     to be NULL-terminated; in this case pass -1 in the corresponding Argl position.\n @param Buffer\n     Buffer that receives the command response. May be NULL.\n @param PSize\n     Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n     contains the number of bytes transferred. May be NULL.\n @param AllowImpersonation\n     Allow caller to be impersonated by launcher.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchCallLauncherPipeEx(
        Command: WCHAR,
        Argc: ULONG,
        Argv: *mut PWSTR,
        Argl: *mut ULONG,
        Buffer: PWSTR,
        PSize: PULONG,
        AllowImpersonation: BOOLEAN,
        PLauncherError: PULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Start a service instance.\n\n @param ClassName\n     Class name of the service instance to start.\n @param InstanceName\n     Instance name of the service instance to start.\n @param Argc\n     Service instance argument count. May be 0.\n @param Argv\n     Service instance argument array. May be NULL.\n @param HasSecret\n     Whether the last argument in Argv is assumed to be a secret (e.g. password) or not.\n     Secrets are passed to service instances through standard input rather than the command\n     line.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchStart(
        ClassName: PWSTR,
        InstanceName: PWSTR,
        Argc: ULONG,
        Argv: *mut PWSTR,
        HasSecret: BOOLEAN,
        PLauncherError: PULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Start a service instance.\n\n @param ClassName\n     Class name of the service instance to start.\n @param InstanceName\n     Instance name of the service instance to start.\n @param Argc\n     Service instance argument count. May be 0.\n @param Argv\n     Service instance argument array. May be NULL.\n @param HasSecret\n     Whether the last argument in Argv is assumed to be a secret (e.g. password) or not.\n     Secrets are passed to service instances through standard input rather than the command\n     line.\n @param AllowImpersonation\n     Allow caller to be impersonated by launcher.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchStartEx(
        ClassName: PWSTR,
        InstanceName: PWSTR,
        Argc: ULONG,
        Argv: *mut PWSTR,
        HasSecret: BOOLEAN,
        AllowImpersonation: BOOLEAN,
        PLauncherError: PULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Stop a service instance.\n\n @param ClassName\n     Class name of the service instance to stop.\n @param InstanceName\n     Instance name of the service instance to stop.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchStop(ClassName: PWSTR, InstanceName: PWSTR, PLauncherError: PULONG)
        -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Get information about a service instance.\n\n The information is a list of NULL-terminated strings: the class name of the service instance,\n the instance name of the service instance and the full command line used to start the service\n instance.\n\n @param ClassName\n     Class name of the service instance to stop.\n @param InstanceName\n     Instance name of the service instance to stop.\n @param Buffer\n     Buffer that receives the command response. May be NULL.\n @param PSize\n     Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n     contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchGetInfo(
        ClassName: PWSTR,
        InstanceName: PWSTR,
        Buffer: PWSTR,
        PSize: PULONG,
        PLauncherError: PULONG,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " List service instances.\n\n The information is a list of pairs of NULL-terminated strings. Each pair contains the class\n name and instance name of a service instance. All currently running service instances are\n listed.\n\n @param Buffer\n     Buffer that receives the command response. May be NULL.\n @param PSize\n     Pointer to a ULONG. On input it contains the size of the Buffer. On output it\n     contains the number of bytes transferred. May be NULL.\n @param PLauncherError\n     Receives the launcher error if any. This is always a Win32 error code. May not be NULL.\n @return\n     STATUS_SUCCESS if the command is sent successfully to the launcher, even if the launcher\n     returns an error. Other status codes indicate a communication error. Launcher errors are\n     reported through PLauncherError."]
    pub fn FspLaunchGetNameList(Buffer: PWSTR, PSize: PULONG, PLauncherError: PULONG) -> NTSTATUS;
}
#[doc = " Service registry record."]
#[repr(C)]
#[derive(Debug)]
pub struct _FSP_LAUNCH_REG_RECORD {
    pub Agent: PWSTR,
    pub Executable: PWSTR,
    pub CommandLine: PWSTR,
    pub WorkDirectory: PWSTR,
    pub RunAs: PWSTR,
    pub Security: PWSTR,
    pub AuthPackage: PWSTR,
    pub Stderr: PWSTR,
    pub Reserved0: [PVOID; 4usize],
    pub JobControl: ULONG,
    pub Credentials: ULONG,
    pub AuthPackageId: ULONG,
    pub Recovery: ULONG,
    pub Reserved1: [ULONG; 4usize],
    pub Buffer: __IncompleteArrayField<UINT8>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _FSP_LAUNCH_REG_RECORD"][::std::mem::size_of::<_FSP_LAUNCH_REG_RECORD>() - 128usize];
    ["Alignment of _FSP_LAUNCH_REG_RECORD"]
        [::std::mem::align_of::<_FSP_LAUNCH_REG_RECORD>() - 8usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Agent"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Agent) - 0usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Executable"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Executable) - 8usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::CommandLine"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, CommandLine) - 16usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::WorkDirectory"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, WorkDirectory) - 24usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::RunAs"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, RunAs) - 32usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Security"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Security) - 40usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::AuthPackage"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, AuthPackage) - 48usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Stderr"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Stderr) - 56usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Reserved0"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Reserved0) - 64usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::JobControl"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, JobControl) - 96usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Credentials"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Credentials) - 100usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::AuthPackageId"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, AuthPackageId) - 104usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Recovery"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Recovery) - 108usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Reserved1"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Reserved1) - 112usize];
    ["Offset of field: _FSP_LAUNCH_REG_RECORD::Buffer"]
        [::std::mem::offset_of!(_FSP_LAUNCH_REG_RECORD, Buffer) - 128usize];
};
impl Default for _FSP_LAUNCH_REG_RECORD {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Service registry record."]
pub type FSP_LAUNCH_REG_RECORD = _FSP_LAUNCH_REG_RECORD;
unsafe extern "C" {
    #[doc = " Add/change/delete a service registry record.\n\n @param ClassName\n     The service class name.\n @param Record\n     The record to set in the registry. If NULL, the registry record is deleted.\n @return\n     STATUS_SUCCESS or error code."]
    pub fn FspLaunchRegSetRecord(
        ClassName: PWSTR,
        Record: *const FSP_LAUNCH_REG_RECORD,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Get a service registry record.\n\n @param ClassName\n     The service class name.\n @param Agent\n     The name of the agent that is retrieving the service record. This API matches\n     the supplied Agent against the Agent in the service record and it only returns\n     the record if they match. Pass NULL to match any Agent.\n @param PRecord\n     Pointer to a record pointer. Memory for the service record will be allocated\n     and a pointer to it will be stored at this address. This memory must be later\n     freed using FspLaunchRegFreeRecord.\n @return\n     STATUS_SUCCESS or error code.\n @see\n     FspLaunchRegFreeRecord"]
    pub fn FspLaunchRegGetRecord(
        ClassName: PWSTR,
        Agent: PWSTR,
        PRecord: *mut *mut FSP_LAUNCH_REG_RECORD,
    ) -> NTSTATUS;
}
unsafe extern "C" {
    #[doc = " Free a service registry record.\n\n @param Record\n     The service record to free.\n @see\n     FspLaunchRegGetRecord"]
    pub fn FspLaunchRegFreeRecord(Record: *mut FSP_LAUNCH_REG_RECORD);
}